[master] Finished merge of trac4009 (use Boost Asio vs. ext/asio)

COPYING

@@ -14,6 +14,6 @@ PERFORMANCE OF THIS SOFTWARE.
 
 -----------------------------------------------------------------------------
 
-The ext/asio and ext/coroutine code is externally maintained and
-distributed under the Boost Software License, Version 1.0.
-(See its accompanying file LICENSE_1_0.txt.)
+The ext/coroutine code is externally maintained and distributed under
+the Boost Software License, Version 1.0.  (See its accompanying file
+LICENSE_1_0.txt.)

ChangeLog

@@ -1,3 +1,11 @@
+1008.	[build]		fdupont
+	Removed the included header-only ASIO code.  Kea is now built
+	against the installed copy of Boost.  The build by default
+	attempts to use the header-only error code (ASIO dependency), but
+	may also use the version in the boost system library.  The
+	location of this library can be specified.
+	(Trac #4009, git xxx)
+
 1007.	[func]		tomek
 	DECLINE message in DHCPv6 is now supported. The server is able
 	to receive it, check its correctness and move the lease to

Makefile.am

@@ -8,6 +8,7 @@ LCOV=@LCOV@
 GENHTML=@GENHTML@
 DISTCHECK_GTEST_CONFIGURE_FLAG=@DISTCHECK_GTEST_CONFIGURE_FLAG@
 DISTCHECK_CRYPTO_CONFIGURE_FLAG=@DISTCHECK_CRYPTO_CONFIGURE_FLAG@
+DISTCHECK_BOOST_CONFIGURE_FLAG=@DISTCHECK_BOOST_CONFIGURE_FLAG@
 
 DISTCLEANFILES = config.report
 
@@ -20,6 +21,9 @@ DISTCHECK_CONFIGURE_FLAGS += $(DISTCHECK_GTEST_CONFIGURE_FLAG)
 # Keep the crypto backend config
 DISTCHECK_CONFIGURE_FLAGS += $(DISTCHECK_CRYPTO_CONFIGURE_FLAG)
 
+# Keep the Boost configuration which becomes sensible
+DISTCHECK_CONFIGURE_FLAGS += $(DISTCHECK_BOOST_CONFIGURE_FLAG)
+
 dist_doc_DATA = AUTHORS COPYING ChangeLog README
 
 .PHONY: check-valgrind check-valgrind-suppress
@@ -64,7 +68,6 @@ report-cpp-coverage:
 if HAVE_BOTAN
 			botan/\* \
 endif
-			ext/asio/\* \
 			ext/coroutine/\* \
 			gtest/\* \
 			include/\* \
@@ -112,313 +115,6 @@ EXTRA_DIST += tools/path_replacer.sh
 EXTRA_DIST += tools/mk_cfgrpt.sh
 
 #### include external sources in the distributed tarball:
-EXTRA_DIST += ext/asio/README
-EXTRA_DIST += ext/asio/README
-EXTRA_DIST += ext/asio/asio.hpp
-EXTRA_DIST += ext/asio/asio/basic_socket.hpp
-EXTRA_DIST += ext/asio/asio/streambuf.hpp
-EXTRA_DIST += ext/asio/asio/thread.hpp
-EXTRA_DIST += ext/asio/asio/detail/wait_handler.hpp
-EXTRA_DIST += ext/asio/asio/detail/resolve_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/gcc_hppa_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/noncopyable.hpp
-EXTRA_DIST += ext/asio/asio/detail/eventfd_select_interrupter.hpp
-EXTRA_DIST += ext/asio/asio/detail/task_io_service_operation.hpp
-EXTRA_DIST += ext/asio/asio/detail/service_base.hpp
-EXTRA_DIST += ext/asio/asio/detail/task_io_service_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_buffers_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_handle_write_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/thread.hpp
-EXTRA_DIST += ext/asio/asio/detail/select_reactor_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/event.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_descriptor_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_overlapped_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_recv_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/macos_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/dev_poll_reactor_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/posix_tss_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/local_free_on_block_exit.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_scheduler.hpp
-EXTRA_DIST += ext/asio/asio/detail/signal_blocker.hpp
-EXTRA_DIST += ext/asio/asio/detail/resolver_service_base.hpp
-EXTRA_DIST += ext/asio/asio/detail/socket_holder.hpp
-EXTRA_DIST += ext/asio/asio/detail/dev_poll_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/select_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/gcc_arm_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/consuming_buffers.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactor_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/base_from_completion_cond.hpp
-EXTRA_DIST += ext/asio/asio/detail/epoll_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/bind_handler.hpp
-EXTRA_DIST += ext/asio/asio/detail/strand_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/op_queue.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_mutex.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_operation.hpp
-EXTRA_DIST += ext/asio/asio/detail/pipe_select_interrupter.hpp
-EXTRA_DIST += ext/asio/asio/detail/wince_thread.hpp
-EXTRA_DIST += ext/asio/asio/detail/buffered_stream_storage.hpp
-EXTRA_DIST += ext/asio/asio/detail/mutex.hpp
-EXTRA_DIST += ext/asio/asio/detail/posix_mutex.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactor_op_queue.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_event.hpp
-EXTRA_DIST += ext/asio/asio/detail/select_interrupter.hpp
-EXTRA_DIST += ext/asio/asio/detail/io_control.hpp
-EXTRA_DIST += ext/asio/asio/detail/buffer_sequence_adapter.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_io_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_handle_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_socket_send_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/epoll_reactor_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/operation.hpp
-EXTRA_DIST += ext/asio/asio/detail/descriptor_ops.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/shared_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/winsock_init.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_queue_set.hpp
-EXTRA_DIST += ext/asio/asio/detail/completion_handler.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_serial_port_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_event.hpp
-EXTRA_DIST += ext/asio/asio/detail/hash_map.hpp
-EXTRA_DIST += ext/asio/asio/detail/gcc_sync_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_tss_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_fd_set_adapter.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_null_buffers_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_queue_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/old_win_sdk_compat.hpp
-EXTRA_DIST += ext/asio/asio/detail/call_stack.hpp
-EXTRA_DIST += ext/asio/asio/detail/weak_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_socket_accept_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/gcc_x86_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/gcc_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_socket_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_mutex.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_recvfrom_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/posix_event.hpp
-EXTRA_DIST += ext/asio/asio/detail/service_id.hpp
-EXTRA_DIST += ext/asio/asio/detail/kqueue_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/regex_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_sendto_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/push_options.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_thread.hpp
-EXTRA_DIST += ext/asio/asio/detail/socket_select_interrupter.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_socket_service_base.hpp
-EXTRA_DIST += ext/asio/asio/detail/throw_error.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_signal_blocker.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_accept_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/wrapped_handler.hpp
-EXTRA_DIST += ext/asio/asio/detail/object_pool.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_scheduler_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/resolve_endpoint_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/array_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/config.hpp
-EXTRA_DIST += ext/asio/asio/detail/socket_option.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_overlapped_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/socket_types.hpp
-EXTRA_DIST += ext/asio/asio/detail/null_tss_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/handler_invoke_helpers.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_send_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_null_buffers_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/pop_options.hpp
-EXTRA_DIST += ext/asio/asio/detail/resolver_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_service_base.hpp
-EXTRA_DIST += ext/asio/asio/detail/descriptor_read_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactive_socket_connect_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_queue_base.hpp
-EXTRA_DIST += ext/asio/asio/detail/reactor_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_socket_recvfrom_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_serial_port_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/tss_ptr.hpp
-EXTRA_DIST += ext/asio/asio/detail/buffer_resize_guard.hpp
-EXTRA_DIST += ext/asio/asio/detail/kqueue_reactor_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_thread.hpp
-EXTRA_DIST += ext/asio/asio/detail/deadline_timer_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_socket_recv_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/posix_thread.hpp
-EXTRA_DIST += ext/asio/asio/detail/signal_init.hpp
-EXTRA_DIST += ext/asio/asio/detail/descriptor_write_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_signal_blocker.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/reactive_socket_service_base.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_mutex.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/posix_event.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_iocp_io_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/select_reactor.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/posix_tss_ptr.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/task_io_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/dev_poll_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/select_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/eventfd_select_interrupter.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/epoll_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/strand_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/winsock_init.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/pipe_select_interrupter.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_iocp_serial_port_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/dev_poll_reactor.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_iocp_io_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/strand_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_iocp_socket_service_base.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/timer_queue.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/posix_mutex.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/reactive_serial_port_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/socket_ops.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/socket_select_interrupter.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/posix_thread.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/reactive_descriptor_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/kqueue_reactor.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/kqueue_reactor.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_event.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/timer_queue_set.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_tss_ptr.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_iocp_handle_service.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/resolver_service_base.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/win_thread.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/task_io_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/throw_error.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/epoll_reactor.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/service_registry.hpp
-EXTRA_DIST += ext/asio/asio/detail/impl/descriptor_ops.ipp
-EXTRA_DIST += ext/asio/asio/detail/impl/service_registry.ipp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_io_service_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/fd_set_adapter.hpp
-EXTRA_DIST += ext/asio/asio/detail/task_io_service.hpp
-EXTRA_DIST += ext/asio/asio/detail/solaris_fenced_block.hpp
-EXTRA_DIST += ext/asio/asio/detail/timer_queue.hpp
-EXTRA_DIST += ext/asio/asio/detail/handler_alloc_helpers.hpp
-EXTRA_DIST += ext/asio/asio/detail/scoped_lock.hpp
-EXTRA_DIST += ext/asio/asio/detail/win_iocp_handle_read_op.hpp
-EXTRA_DIST += ext/asio/asio/detail/service_registry_fwd.hpp
-EXTRA_DIST += ext/asio/asio/detail/service_registry.hpp
-EXTRA_DIST += ext/asio/asio/detail/posix_fd_set_adapter.hpp
-EXTRA_DIST += ext/asio/asio/detail/socket_ops.hpp
-EXTRA_DIST += ext/asio/asio/detail/posix_signal_blocker.hpp
-EXTRA_DIST += ext/asio/asio/serial_port_base.hpp
-EXTRA_DIST += ext/asio/asio/ssl/context_base.hpp
-EXTRA_DIST += ext/asio/asio/ssl/context.hpp
-EXTRA_DIST += ext/asio/asio/ssl/context_service.hpp
-EXTRA_DIST += ext/asio/asio/ssl/detail/openssl_types.hpp
-EXTRA_DIST += ext/asio/asio/ssl/detail/openssl_context_service.hpp
-EXTRA_DIST += ext/asio/asio/ssl/detail/openssl_stream_service.hpp
-EXTRA_DIST += ext/asio/asio/ssl/detail/openssl_operation.hpp
-EXTRA_DIST += ext/asio/asio/ssl/detail/openssl_init.hpp
-EXTRA_DIST += ext/asio/asio/ssl/basic_context.hpp
-EXTRA_DIST += ext/asio/asio/ssl/stream_service.hpp
-EXTRA_DIST += ext/asio/asio/ssl/stream.hpp
-EXTRA_DIST += ext/asio/asio/ssl/stream_base.hpp
-EXTRA_DIST += ext/asio/asio/basic_streambuf.hpp
-EXTRA_DIST += ext/asio/asio/serial_port_service.hpp
-EXTRA_DIST += ext/asio/asio/error.hpp
-EXTRA_DIST += ext/asio/asio/handler_alloc_hook.hpp
-EXTRA_DIST += ext/asio/asio/buffers_iterator.hpp
-EXTRA_DIST += ext/asio/asio/is_read_buffered.hpp
-EXTRA_DIST += ext/asio/asio/buffered_stream_fwd.hpp
-EXTRA_DIST += ext/asio/asio/placeholders.hpp
-EXTRA_DIST += ext/asio/asio/local/stream_protocol.hpp
-EXTRA_DIST += ext/asio/asio/local/detail/impl/endpoint.ipp
-EXTRA_DIST += ext/asio/asio/local/detail/endpoint.hpp
-EXTRA_DIST += ext/asio/asio/local/datagram_protocol.hpp
-EXTRA_DIST += ext/asio/asio/local/connect_pair.hpp
-EXTRA_DIST += ext/asio/asio/local/basic_endpoint.hpp
-EXTRA_DIST += ext/asio/asio/buffered_stream.hpp
-EXTRA_DIST += ext/asio/asio/basic_serial_port.hpp
-EXTRA_DIST += ext/asio/asio/datagram_socket_service.hpp
-EXTRA_DIST += ext/asio/asio/socket_base.hpp
-EXTRA_DIST += ext/asio/asio/io_service.hpp
-EXTRA_DIST += ext/asio/asio/ssl.hpp
-EXTRA_DIST += ext/asio/asio/basic_socket_iostream.hpp
-EXTRA_DIST += ext/asio/asio/basic_io_object.hpp
-EXTRA_DIST += ext/asio/asio/basic_socket_streambuf.hpp
-EXTRA_DIST += ext/asio/asio/error_code.hpp
-EXTRA_DIST += ext/asio/asio/basic_stream_socket.hpp
-EXTRA_DIST += ext/asio/asio/read_until.hpp
-EXTRA_DIST += ext/asio/asio/basic_streambuf_fwd.hpp
-EXTRA_DIST += ext/asio/asio/is_write_buffered.hpp
-EXTRA_DIST += ext/asio/asio/basic_datagram_socket.hpp
-EXTRA_DIST += ext/asio/asio/buffered_write_stream_fwd.hpp
-EXTRA_DIST += ext/asio/asio/basic_deadline_timer.hpp
-EXTRA_DIST += ext/asio/asio/socket_acceptor_service.hpp
-EXTRA_DIST += ext/asio/asio/raw_socket_service.hpp
-EXTRA_DIST += ext/asio/asio/buffered_read_stream.hpp
-EXTRA_DIST += ext/asio/asio/time_traits.hpp
-EXTRA_DIST += ext/asio/asio/completion_condition.hpp
-EXTRA_DIST += ext/asio/asio/posix/basic_stream_descriptor.hpp
-EXTRA_DIST += ext/asio/asio/posix/basic_descriptor.hpp
-EXTRA_DIST += ext/asio/asio/posix/descriptor_base.hpp
-EXTRA_DIST += ext/asio/asio/posix/stream_descriptor_service.hpp
-EXTRA_DIST += ext/asio/asio/posix/stream_descriptor.hpp
-EXTRA_DIST += ext/asio/asio/write.hpp
-EXTRA_DIST += ext/asio/asio/write_at.hpp
-EXTRA_DIST += ext/asio/asio/basic_raw_socket.hpp
-EXTRA_DIST += ext/asio/asio/serial_port.hpp
-EXTRA_DIST += ext/asio/asio/windows/basic_stream_handle.hpp
-EXTRA_DIST += ext/asio/asio/windows/basic_handle.hpp
-EXTRA_DIST += ext/asio/asio/windows/random_access_handle.hpp
-EXTRA_DIST += ext/asio/asio/windows/overlapped_ptr.hpp
-EXTRA_DIST += ext/asio/asio/windows/stream_handle.hpp
-EXTRA_DIST += ext/asio/asio/windows/random_access_handle_service.hpp
-EXTRA_DIST += ext/asio/asio/windows/stream_handle_service.hpp
-EXTRA_DIST += ext/asio/asio/windows/basic_random_access_handle.hpp
-EXTRA_DIST += ext/asio/asio/read.hpp
-EXTRA_DIST += ext/asio/asio/deadline_timer_service.hpp
-EXTRA_DIST += ext/asio/asio/buffered_write_stream.hpp
-EXTRA_DIST += ext/asio/asio/buffer.hpp
-EXTRA_DIST += ext/asio/asio/impl/read_until.ipp
-EXTRA_DIST += ext/asio/asio/impl/serial_port_base.hpp
-EXTRA_DIST += ext/asio/asio/impl/read_at.ipp
-EXTRA_DIST += ext/asio/asio/impl/read.ipp
-EXTRA_DIST += ext/asio/asio/impl/error.ipp
-EXTRA_DIST += ext/asio/asio/impl/io_service.ipp
-EXTRA_DIST += ext/asio/asio/impl/io_service.hpp
-EXTRA_DIST += ext/asio/asio/impl/src.hpp
-EXTRA_DIST += ext/asio/asio/impl/src.cpp
-EXTRA_DIST += ext/asio/asio/impl/read_until.hpp
-EXTRA_DIST += ext/asio/asio/impl/serial_port_base.ipp
-EXTRA_DIST += ext/asio/asio/impl/write.hpp
-EXTRA_DIST += ext/asio/asio/impl/write_at.hpp
-EXTRA_DIST += ext/asio/asio/impl/write.ipp
-EXTRA_DIST += ext/asio/asio/impl/read.hpp
-EXTRA_DIST += ext/asio/asio/impl/write_at.ipp
-EXTRA_DIST += ext/asio/asio/impl/error_code.ipp
-EXTRA_DIST += ext/asio/asio/impl/read_at.hpp
-EXTRA_DIST += ext/asio/asio/strand.hpp
-EXTRA_DIST += ext/asio/asio/version.hpp
-EXTRA_DIST += ext/asio/asio/basic_socket_acceptor.hpp
-EXTRA_DIST += ext/asio/asio/ip/basic_resolver_query.hpp
-EXTRA_DIST += ext/asio/asio/ip/address.hpp
-EXTRA_DIST += ext/asio/asio/ip/host_name.hpp
-EXTRA_DIST += ext/asio/asio/ip/detail/socket_option.hpp
-EXTRA_DIST += ext/asio/asio/ip/detail/impl/endpoint.ipp
-EXTRA_DIST += ext/asio/asio/ip/detail/endpoint.hpp
-EXTRA_DIST += ext/asio/asio/ip/udp.hpp
-EXTRA_DIST += ext/asio/asio/ip/basic_resolver_iterator.hpp
-EXTRA_DIST += ext/asio/asio/ip/v6_only.hpp
-EXTRA_DIST += ext/asio/asio/ip/address_v4.hpp
-EXTRA_DIST += ext/asio/asio/ip/resolver_query_base.hpp
-EXTRA_DIST += ext/asio/asio/ip/multicast.hpp
-EXTRA_DIST += ext/asio/asio/ip/address_v6.hpp
-EXTRA_DIST += ext/asio/asio/ip/tcp.hpp
-EXTRA_DIST += ext/asio/asio/ip/basic_resolver_entry.hpp
-EXTRA_DIST += ext/asio/asio/ip/unicast.hpp
-EXTRA_DIST += ext/asio/asio/ip/resolver_service.hpp
-EXTRA_DIST += ext/asio/asio/ip/icmp.hpp
-EXTRA_DIST += ext/asio/asio/ip/basic_endpoint.hpp
-EXTRA_DIST += ext/asio/asio/ip/basic_resolver.hpp
-EXTRA_DIST += ext/asio/asio/ip/impl/address.hpp
-EXTRA_DIST += ext/asio/asio/ip/impl/address_v4.hpp
-EXTRA_DIST += ext/asio/asio/ip/impl/address_v4.ipp
-EXTRA_DIST += ext/asio/asio/ip/impl/address_v6.hpp
-EXTRA_DIST += ext/asio/asio/ip/impl/address.ipp
-EXTRA_DIST += ext/asio/asio/ip/impl/host_name.ipp
-EXTRA_DIST += ext/asio/asio/ip/impl/basic_endpoint.hpp
-EXTRA_DIST += ext/asio/asio/ip/impl/address_v6.ipp
-EXTRA_DIST += ext/asio/asio/handler_invoke_hook.hpp
-EXTRA_DIST += ext/asio/asio/read_at.hpp
-EXTRA_DIST += ext/asio/asio/buffered_read_stream_fwd.hpp
-EXTRA_DIST += ext/asio/asio/system_error.hpp
-EXTRA_DIST += ext/asio/asio/deadline_timer.hpp
-EXTRA_DIST += ext/asio/asio/stream_socket_service.hpp
 EXTRA_DIST += ext/coroutine/coroutine.h
 
 pkgconfigdir = $(libdir)/pkgconfig

configure.ac

@@ -1241,15 +1241,22 @@ AC_SUBST(GTEST_SOURCE)
 #
 # ASIO: we extensively use it as the C++ event management module.
 #
-# Use local ASIO headers from ext
-#
-CPPFLAGS="$CPPFLAGS -I\$(top_srcdir)/ext/asio"
-#
 # Use our 'coroutine' header from ext
 CPPFLAGS="$CPPFLAGS -I\$(top_srcdir)/ext/coroutine"
 #
+# Doesn't seem to be required?
+CPPFLAGS="$CPPFLAGS -DBOOST_ASIO_HEADER_ONLY"
+#
 # Disable threads: Currently we don't use them.
-CPPFLAGS="$CPPFLAGS -DASIO_DISABLE_THREADS=1"
+CPPFLAGS="$CPPFLAGS -DBOOST_ASIO_DISABLE_THREADS=1"
+
+# We tried to stay header only
+if test "x${BOOST_LIBS}" = "x"; then
+   # Don't want boost system library
+   CPPFLAGS="$CPPFLAGS -DBOOST_ERROR_CODE_HEADER_ONLY"
+   # Avoid boost::system::throws multiple defines
+   CPPFLAGS="$CPPFLAGS -DBOOST_SYSTEM_NO_DEPRECATED"
+fi
 
 # Check for functions that are not available on all platforms
 AC_CHECK_FUNCS([pselect])
@@ -1266,7 +1273,7 @@ AC_CHECK_FUNCS([pselect])
 # code will be updated by the time we really need it.
 AC_CHECK_HEADERS(sys/devpoll.h, ac_cv_have_devpoll=yes, ac_cv_have_devpoll=no)
 if test "X$ac_cv_have_devpoll" = "Xyes" -a "X$GXX" = "Xyes"; then
-	CPPFLAGS="$CPPFLAGS -DASIO_DISABLE_DEV_POLL=1"
+	CPPFLAGS="$CPPFLAGS -DBOOST_ASIO_DISABLE_DEV_POLL=1"
 fi
 
 #
@@ -1380,8 +1387,7 @@ AC_CONFIG_FILES([compatcheck/Makefile
                  doc/guide/Makefile
                  doc/Makefile
                  doc/version.ent
-                 ext/asio/asio/Makefile
-                 ext/asio/Makefile
+                 ext/coroutine/Makefile
                  ext/gtest/Makefile
                  ext/Makefile
                  m4macros/Makefile
@@ -1570,6 +1576,7 @@ cat >> config.report << END
 Boost:
   BOOST_VERSION:   ${BOOST_VERSION}
   BOOST_INCLUDES:  ${BOOST_INCLUDES}
+  BOOST_LIBS:      ${BOOST_LIBS}
 
 ${CRYPTO_NAME}:
   CRYPTO_VERSION:  ${CRYPTO_VERSION}

doc/guide/install.xml

@@ -109,6 +109,8 @@
           At least Boost version 1.35 is required.
   <!-- TODO: we don't check for this version -->
   <!-- NOTE: jreed has tested with 1.34, 1.38, and 1.41. -->
+          When header-only Boost error code is not available or wanted, the
+          Boost system library is required too.
         </para>
         </listitem>
 
@@ -256,9 +258,28 @@ Debian and Ubuntu:
           </varlistentry>
 
           <varlistentry>
+            <term>--with-boost-libs</term>
+            <listitem>
+              <simpara>Specify Boost libraries to link with (this option
+                exists only to provide a way to enforce such a list:
+                usually this should not be used).
+              </simpara>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
+            <term>--with-boost-lib-dir</term>
+            <listitem>
+              <simpara>Specify the path to Boost libraries to link with
+                (usually there should be no reason to specify this option).
+              </simpara>
+            </listitem>
+          </varlistentry>
+
+          <varlistentry>
             <term>--with-botan-config</term>
             <listitem>
-              <simpara>To specific the path to the botan-config
+              <simpara>Specify the path to the botan-config
                 script to build with Botan for the crypto code.
               </simpara>
             </listitem>
@@ -330,6 +351,16 @@ Debian and Ubuntu:
         </para>
 
         <para>
+          If you have some problems with building Kea using the header-only
+          Boost error code or you'd like to use the Boost system library
+          (e.g., located in /usr/pkg/lib):
+
+          <screen>$ <userinput>./configure \
+      --with-boost-libs=-lboost_system \
+      --with-boost-lib-dir=/usr/pkg/lib</userinput></screen>
+        </para>
+
+        <para>
           If the configure fails, it may be due to missing or old
           dependencies.
         </para>

ext/Makefile.am

@@ -1,11 +1,5 @@
-SUBDIRS = . asio
+SUBDIRS = coroutine
+
 if HAVE_GTEST_SOURCE
 SUBDIRS += gtest
 endif
-
-# As we are copying ASIO headers to the installation directory, copy across
-# the licence file as well.
-asio_datadir = $(pkgincludedir)/asio
-asio_data_DATA = LICENSE_1_0.txt
-
-EXTRA_DIST = LICENSE_1_0.txt

ext/asio/Makefile.am

@@ -1,6 +0,0 @@
-SUBDIRS = . asio
-
-# As we are copying across the ASIO files to the installation directory, copy
-# across the README that tells us where we got them from.
-asio_datadir = $(pkgincludedir)/asio
-asio_data_DATA = README

ext/asio/README

@@ -1,21 +0,0 @@
-ASIO library header files
-Version 1.4.8 (2011-04-19)
-Downloaded from http://sourceforge.net/projects/asio/files
-Project page: http://think-async.com/Asio
-
-Local modifications:
-
-Imported a kqueue bug fix from Asio 1.5.1.
-git commit e4b2c2633ebb3859286e9a4c19e97e17bcac41b3
-See
-http://sourceforge.net/p/asio/git/ci/a50b53864f77fe762f21e44a281235982dd7e733/
-
-Added ASIO_DECL to a number of function definitions
-git commit c32718be9f5409b6f72d98ddcd0b1ccd4c5c2293
-See also the bug report at:
-http://sourceforge.net/tracker/?func=detail&aid=3291113&group_id=122478&atid=694037
-
-Imported a fix from Asio 1.5.2.
-git commit cf00216570a36d2e3e688b197deea781bfbe7d8d
-See
-http://sourceforge.net/p/asio/git/ci/4820fd6f0d257a6bb554fcd1f97f170330be0448/log/?path=/asio/include/asio/detail/impl/socket_ops.ipp

ext/asio/asio.hpp

@@ -1,101 +0,0 @@
-//
-// asio.hpp
-// ~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_HPP
-#define ASIO_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/basic_datagram_socket.hpp"
-#include "asio/basic_deadline_timer.hpp"
-#include "asio/basic_io_object.hpp"
-#include "asio/basic_raw_socket.hpp"
-#include "asio/basic_serial_port.hpp"
-#include "asio/basic_socket_acceptor.hpp"
-#include "asio/basic_socket_iostream.hpp"
-#include "asio/basic_socket_streambuf.hpp"
-#include "asio/basic_stream_socket.hpp"
-#include "asio/basic_streambuf.hpp"
-#include "asio/buffer.hpp"
-#include "asio/buffered_read_stream_fwd.hpp"
-#include "asio/buffered_read_stream.hpp"
-#include "asio/buffered_stream_fwd.hpp"
-#include "asio/buffered_stream.hpp"
-#include "asio/buffered_write_stream_fwd.hpp"
-#include "asio/buffered_write_stream.hpp"
-#include "asio/buffers_iterator.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/datagram_socket_service.hpp"
-#include "asio/deadline_timer_service.hpp"
-#include "asio/deadline_timer.hpp"
-#include "asio/error.hpp"
-#include "asio/error_code.hpp"
-#include "asio/handler_alloc_hook.hpp"
-#include "asio/handler_invoke_hook.hpp"
-#include "asio/io_service.hpp"
-#include "asio/ip/address.hpp"
-#include "asio/ip/address_v4.hpp"
-#include "asio/ip/address_v6.hpp"
-#include "asio/ip/basic_endpoint.hpp"
-#include "asio/ip/basic_resolver.hpp"
-#include "asio/ip/basic_resolver_entry.hpp"
-#include "asio/ip/basic_resolver_iterator.hpp"
-#include "asio/ip/basic_resolver_query.hpp"
-#include "asio/ip/host_name.hpp"
-#include "asio/ip/icmp.hpp"
-#include "asio/ip/multicast.hpp"
-#include "asio/ip/resolver_query_base.hpp"
-#include "asio/ip/resolver_service.hpp"
-#include "asio/ip/tcp.hpp"
-#include "asio/ip/udp.hpp"
-#include "asio/ip/unicast.hpp"
-#include "asio/ip/v6_only.hpp"
-#include "asio/is_read_buffered.hpp"
-#include "asio/is_write_buffered.hpp"
-#include "asio/local/basic_endpoint.hpp"
-#include "asio/local/connect_pair.hpp"
-#include "asio/local/datagram_protocol.hpp"
-#include "asio/local/stream_protocol.hpp"
-#include "asio/placeholders.hpp"
-#include "asio/posix/basic_descriptor.hpp"
-#include "asio/posix/basic_stream_descriptor.hpp"
-#include "asio/posix/descriptor_base.hpp"
-#include "asio/posix/stream_descriptor.hpp"
-#include "asio/posix/stream_descriptor_service.hpp"
-#include "asio/raw_socket_service.hpp"
-#include "asio/read.hpp"
-#include "asio/read_at.hpp"
-#include "asio/read_until.hpp"
-#include "asio/serial_port.hpp"
-#include "asio/serial_port_base.hpp"
-#include "asio/serial_port_service.hpp"
-#include "asio/socket_acceptor_service.hpp"
-#include "asio/socket_base.hpp"
-#include "asio/strand.hpp"
-#include "asio/stream_socket_service.hpp"
-#include "asio/streambuf.hpp"
-#include "asio/system_error.hpp"
-#include "asio/thread.hpp"
-#include "asio/time_traits.hpp"
-#include "asio/version.hpp"
-#include "asio/windows/basic_handle.hpp"
-#include "asio/windows/basic_random_access_handle.hpp"
-#include "asio/windows/basic_stream_handle.hpp"
-#include "asio/windows/overlapped_ptr.hpp"
-#include "asio/windows/random_access_handle.hpp"
-#include "asio/windows/random_access_handle_service.hpp"
-#include "asio/windows/stream_handle.hpp"
-#include "asio/windows/stream_handle_service.hpp"
-#include "asio/write.hpp"
-#include "asio/write_at.hpp"
-
-#endif // ASIO_HPP

ext/asio/asio/Makefile.am

@@ -1,310 +0,0 @@
-SUBDIRS = .
-
-# Copy across the BIND 10 copy of ASIO to the installation directory, as some
-# header files used by user-libraries may use parts of it.
-asio_includedir = $(pkgincludedir)/asio
-nobase_asio_include_HEADERS = \
-    basic_datagram_socket.hpp \
-    basic_deadline_timer.hpp \
-    basic_io_object.hpp \
-    basic_raw_socket.hpp \
-    basic_serial_port.hpp \
-    basic_socket.hpp \
-    basic_socket_acceptor.hpp \
-    basic_socket_iostream.hpp \
-    basic_socket_streambuf.hpp \
-    basic_stream_socket.hpp \
-    basic_streambuf.hpp \
-    basic_streambuf_fwd.hpp \
-    buffer.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 \
-    completion_condition.hpp \
-    datagram_socket_service.hpp \
-    deadline_timer.hpp \
-    deadline_timer_service.hpp \
-    detail/array_fwd.hpp \
-    detail/base_from_completion_cond.hpp \
-    detail/bind_handler.hpp \
-    detail/buffer_resize_guard.hpp \
-    detail/buffer_sequence_adapter.hpp \
-    detail/buffered_stream_storage.hpp \
-    detail/call_stack.hpp \
-    detail/completion_handler.hpp \
-    detail/config.hpp \
-    detail/consuming_buffers.hpp \
-    detail/deadline_timer_service.hpp \
-    detail/descriptor_ops.hpp \
-    detail/descriptor_read_op.hpp \
-    detail/descriptor_write_op.hpp \
-    detail/dev_poll_reactor.hpp \
-    detail/dev_poll_reactor_fwd.hpp \
-    detail/epoll_reactor.hpp \
-    detail/epoll_reactor_fwd.hpp \
-    detail/event.hpp \
-    detail/eventfd_select_interrupter.hpp \
-    detail/fd_set_adapter.hpp \
-    detail/fenced_block.hpp \
-    detail/gcc_arm_fenced_block.hpp \
-    detail/gcc_fenced_block.hpp \
-    detail/gcc_hppa_fenced_block.hpp \
-    detail/gcc_sync_fenced_block.hpp \
-    detail/gcc_x86_fenced_block.hpp \
-    detail/handler_alloc_helpers.hpp \
-    detail/handler_invoke_helpers.hpp \
-    detail/hash_map.hpp \
-    detail/impl/descriptor_ops.ipp \
-    detail/impl/dev_poll_reactor.hpp \
-    detail/impl/dev_poll_reactor.ipp \
-    detail/impl/epoll_reactor.hpp \
-    detail/impl/epoll_reactor.ipp \
-    detail/impl/eventfd_select_interrupter.ipp \
-    detail/impl/kqueue_reactor.hpp \
-    detail/impl/kqueue_reactor.ipp \
-    detail/impl/pipe_select_interrupter.ipp \
-    detail/impl/posix_event.ipp \
-    detail/impl/posix_mutex.ipp \
-    detail/impl/posix_thread.ipp \
-    detail/impl/posix_tss_ptr.ipp \
-    detail/impl/reactive_descriptor_service.ipp \
-    detail/impl/reactive_serial_port_service.ipp \
-    detail/impl/reactive_socket_service_base.ipp \
-    detail/impl/resolver_service_base.ipp \
-    detail/impl/select_reactor.hpp \
-    detail/impl/select_reactor.ipp \
-    detail/impl/service_registry.hpp \
-    detail/impl/service_registry.ipp \
-    detail/impl/socket_ops.ipp \
-    detail/impl/socket_select_interrupter.ipp \
-    detail/impl/strand_service.hpp \
-    detail/impl/strand_service.ipp \
-    detail/impl/task_io_service.hpp \
-    detail/impl/task_io_service.ipp \
-    detail/impl/throw_error.ipp \
-    detail/impl/timer_queue.ipp \
-    detail/impl/timer_queue_set.ipp \
-    detail/impl/win_event.ipp \
-    detail/impl/win_iocp_handle_service.ipp \
-    detail/impl/win_iocp_io_service.hpp \
-    detail/impl/win_iocp_io_service.ipp \
-    detail/impl/win_iocp_serial_port_service.ipp \
-    detail/impl/win_iocp_socket_service_base.ipp \
-    detail/impl/win_mutex.ipp \
-    detail/impl/win_thread.ipp \
-    detail/impl/win_tss_ptr.ipp \
-    detail/impl/winsock_init.ipp \
-    detail/io_control.hpp \
-    detail/kqueue_reactor.hpp \
-    detail/kqueue_reactor_fwd.hpp \
-    detail/local_free_on_block_exit.hpp \
-    detail/macos_fenced_block.hpp \
-    detail/mutex.hpp \
-    detail/noncopyable.hpp \
-    detail/null_buffers_op.hpp \
-    detail/null_event.hpp \
-    detail/null_fenced_block.hpp \
-    detail/null_mutex.hpp \
-    detail/null_signal_blocker.hpp \
-    detail/null_thread.hpp \
-    detail/null_tss_ptr.hpp \
-    detail/object_pool.hpp \
-    detail/old_win_sdk_compat.hpp \
-    detail/op_queue.hpp \
-    detail/operation.hpp \
-    detail/pipe_select_interrupter.hpp \
-    detail/pop_options.hpp \
-    detail/posix_event.hpp \
-    detail/posix_fd_set_adapter.hpp \
-    detail/posix_mutex.hpp \
-    detail/posix_signal_blocker.hpp \
-    detail/posix_thread.hpp \
-    detail/posix_tss_ptr.hpp \
-    detail/push_options.hpp \
-    detail/reactive_descriptor_service.hpp \
-    detail/reactive_null_buffers_op.hpp \
-    detail/reactive_serial_port_service.hpp \
-    detail/reactive_socket_accept_op.hpp \
-    detail/reactive_socket_connect_op.hpp \
-    detail/reactive_socket_recv_op.hpp \
-    detail/reactive_socket_recvfrom_op.hpp \
-    detail/reactive_socket_send_op.hpp \
-    detail/reactive_socket_sendto_op.hpp \
-    detail/reactive_socket_service.hpp \
-    detail/reactive_socket_service_base.hpp \
-    detail/reactor.hpp \
-    detail/reactor_fwd.hpp \
-    detail/reactor_op.hpp \
-    detail/reactor_op_queue.hpp \
-    detail/regex_fwd.hpp \
-    detail/resolve_endpoint_op.hpp \
-    detail/resolve_op.hpp \
-    detail/resolver_service.hpp \
-    detail/resolver_service_base.hpp \
-    detail/scoped_lock.hpp \
-    detail/select_interrupter.hpp \
-    detail/select_reactor.hpp \
-    detail/select_reactor_fwd.hpp \
-    detail/service_base.hpp \
-    detail/service_id.hpp \
-    detail/service_registry.hpp \
-    detail/service_registry_fwd.hpp \
-    detail/shared_ptr.hpp \
-    detail/signal_blocker.hpp \
-    detail/signal_init.hpp \
-    detail/socket_holder.hpp \
-    detail/socket_ops.hpp \
-    detail/socket_option.hpp \
-    detail/socket_select_interrupter.hpp \
-    detail/socket_types.hpp \
-    detail/solaris_fenced_block.hpp \
-    detail/strand_service.hpp \
-    detail/task_io_service.hpp \
-    detail/task_io_service_fwd.hpp \
-    detail/task_io_service_operation.hpp \
-    detail/thread.hpp \
-    detail/throw_error.hpp \
-    detail/timer_op.hpp \
-    detail/timer_queue.hpp \
-    detail/timer_queue_base.hpp \
-    detail/timer_queue_fwd.hpp \
-    detail/timer_queue_set.hpp \
-    detail/timer_scheduler.hpp \
-    detail/timer_scheduler_fwd.hpp \
-    detail/tss_ptr.hpp \
-    detail/wait_handler.hpp \
-    detail/weak_ptr.hpp \
-    detail/win_event.hpp \
-    detail/win_fd_set_adapter.hpp \
-    detail/win_fenced_block.hpp \
-    detail/win_iocp_handle_read_op.hpp \
-    detail/win_iocp_handle_service.hpp \
-    detail/win_iocp_handle_write_op.hpp \
-    detail/win_iocp_io_service.hpp \
-    detail/win_iocp_io_service_fwd.hpp \
-    detail/win_iocp_null_buffers_op.hpp \
-    detail/win_iocp_operation.hpp \
-    detail/win_iocp_overlapped_op.hpp \
-    detail/win_iocp_overlapped_ptr.hpp \
-    detail/win_iocp_serial_port_service.hpp \
-    detail/win_iocp_socket_accept_op.hpp \
-    detail/win_iocp_socket_recv_op.hpp \
-    detail/win_iocp_socket_recvfrom_op.hpp \
-    detail/win_iocp_socket_send_op.hpp \
-    detail/win_iocp_socket_service.hpp \
-    detail/win_iocp_socket_service_base.hpp \
-    detail/win_mutex.hpp \
-    detail/win_signal_blocker.hpp \
-    detail/win_thread.hpp \
-    detail/win_tss_ptr.hpp \
-    detail/wince_thread.hpp \
-    detail/winsock_init.hpp \
-    detail/wrapped_handler.hpp \
-    error.hpp \
-    error_code.hpp \
-    handler_alloc_hook.hpp \
-    handler_invoke_hook.hpp \
-    impl/error.ipp \
-    impl/error_code.ipp \
-    impl/io_service.hpp \
-    impl/io_service.ipp \
-    impl/read.hpp \
-    impl/read.ipp \
-    impl/read_at.hpp \
-    impl/read_at.ipp \
-    impl/read_until.hpp \
-    impl/read_until.ipp \
-    impl/serial_port_base.hpp \
-    impl/serial_port_base.ipp \
-    impl/src.cpp \
-    impl/src.hpp \
-    impl/write.hpp \
-    impl/write.ipp \
-    impl/write_at.hpp \
-    impl/write_at.ipp \
-    io_service.hpp \
-    ip/address.hpp \
-    ip/address_v4.hpp \
-    ip/address_v6.hpp \
-    ip/basic_endpoint.hpp \
-    ip/basic_resolver.hpp \
-    ip/basic_resolver_entry.hpp \
-    ip/basic_resolver_iterator.hpp \
-    ip/basic_resolver_query.hpp \
-    ip/detail/endpoint.hpp \
-    ip/detail/impl/endpoint.ipp \
-    ip/detail/socket_option.hpp \
-    ip/host_name.hpp \
-    ip/icmp.hpp \
-    ip/impl/address.hpp \
-    ip/impl/address.ipp \
-    ip/impl/address_v4.hpp \
-    ip/impl/address_v4.ipp \
-    ip/impl/address_v6.hpp \
-    ip/impl/address_v6.ipp \
-    ip/impl/basic_endpoint.hpp \
-    ip/impl/host_name.ipp \
-    ip/multicast.hpp \
-    ip/resolver_query_base.hpp \
-    ip/resolver_service.hpp \
-    ip/tcp.hpp \
-    ip/udp.hpp \
-    ip/unicast.hpp \
-    ip/v6_only.hpp \
-    is_read_buffered.hpp \
-    is_write_buffered.hpp \
-    local/basic_endpoint.hpp \
-    local/connect_pair.hpp \
-    local/datagram_protocol.hpp \
-    local/detail/endpoint.hpp \
-    local/detail/impl/endpoint.ipp \
-    local/stream_protocol.hpp \
-    placeholders.hpp \
-    posix/basic_descriptor.hpp \
-    posix/basic_stream_descriptor.hpp \
-    posix/descriptor_base.hpp \
-    posix/stream_descriptor.hpp \
-    posix/stream_descriptor_service.hpp \
-    raw_socket_service.hpp \
-    read.hpp \
-    read_at.hpp \
-    read_until.hpp \
-    serial_port.hpp \
-    serial_port_base.hpp \
-    serial_port_service.hpp \
-    socket_acceptor_service.hpp \
-    socket_base.hpp \
-    ssl.hpp \
-    ssl/basic_context.hpp \
-    ssl/context.hpp \
-    ssl/context_base.hpp \
-    ssl/context_service.hpp \
-    ssl/detail/openssl_context_service.hpp \
-    ssl/detail/openssl_init.hpp \
-    ssl/detail/openssl_operation.hpp \
-    ssl/detail/openssl_stream_service.hpp \
-    ssl/detail/openssl_types.hpp \
-    ssl/stream.hpp \
-    ssl/stream_base.hpp \
-    ssl/stream_service.hpp \
-    strand.hpp \
-    stream_socket_service.hpp \
-    streambuf.hpp \
-    system_error.hpp \
-    thread.hpp \
-    time_traits.hpp \
-    version.hpp \
-    windows/basic_handle.hpp \
-    windows/basic_random_access_handle.hpp \
-    windows/basic_stream_handle.hpp \
-    windows/overlapped_ptr.hpp \
-    windows/random_access_handle.hpp \
-    windows/random_access_handle_service.hpp \
-    windows/stream_handle.hpp \
-    windows/stream_handle_service.hpp \
-    write.hpp \
-    write_at.hpp

ext/asio/asio/basic_datagram_socket.hpp

@@ -1,800 +0,0 @@
-//
-// basic_datagram_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_DATAGRAM_SOCKET_HPP
-#define ASIO_BASIC_DATAGRAM_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_socket.hpp"
-#include "asio/datagram_socket_service.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides datagram-oriented socket functionality.
-/**
- * The basic_datagram_socket class template provides asynchronous and blocking
- * datagram-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Protocol,
-    typename DatagramSocketService = datagram_socket_service<Protocol> >
-class basic_datagram_socket
-  : public basic_socket<Protocol, DatagramSocketService>
-{
-public:
-  /// The native representation of a socket.
-  typedef typename DatagramSocketService::native_type native_type;
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_datagram_socket without opening it.
-  /**
-   * This constructor creates a datagram socket without opening it. The open()
-   * function must be called before data can be sent or received on the socket.
-   *
-   * @param io_service The io_service object that the datagram socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   */
-  explicit basic_datagram_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, DatagramSocketService>(io_service)
-  {
-  }
-
-  /// Construct and open a basic_datagram_socket.
-  /**
-   * This constructor creates and opens a datagram socket.
-   *
-   * @param io_service The io_service object that the datagram socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_datagram_socket(asio::io_service& io_service,
-      const protocol_type& protocol)
-    : basic_socket<Protocol, DatagramSocketService>(io_service, protocol)
-  {
-  }
-
-  /// Construct a basic_datagram_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a datagram socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param io_service The io_service object that the datagram socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the datagram
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_datagram_socket(asio::io_service& io_service,
-      const endpoint_type& endpoint)
-    : basic_socket<Protocol, DatagramSocketService>(io_service, endpoint)
-  {
-  }
-
-  /// Construct a basic_datagram_socket on an existing native socket.
-  /**
-   * This constructor creates a datagram socket object to hold an existing
-   * native socket.
-   *
-   * @param io_service The io_service object that the datagram socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_datagram_socket(asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
-    : basic_socket<Protocol, DatagramSocketService>(
-        io_service, protocol, native_socket)
-  {
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected datagram socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code socket.send(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected datagram socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected datagram socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->service.send(this->implementation, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected datagram
-   * socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers, WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, 0, handler);
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected datagram
-   * socket.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, flags, handler);
-  }
-
-  /// Send a datagram to the specified endpoint.
-  /**
-   * This function is used to send a datagram to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.send_to(asio::buffer(data, size), destination);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send a datagram to the specified endpoint.
-  /**
-   * This function is used to send a datagram to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send a datagram to the specified endpoint.
-  /**
-   * This function is used to send a datagram to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->service.send_to(this->implementation,
-        buffers, destination, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.async_send_to(
-   *     asio::buffer(data, size), destination, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, WriteHandler handler)
-  {
-    this->service.async_send_to(this->implementation, buffers, destination, 0,
-        handler);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send a datagram to the specified
-   * remote endpoint. The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      WriteHandler handler)
-  {
-    this->service.async_send_to(this->implementation, buffers, destination,
-        flags, handler);
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the datagram socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected datagram
-   * socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.receive(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the datagram socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected datagram
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the datagram socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected datagram
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->service.receive(this->implementation, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the datagram
-   * socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * datagram socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers, ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the datagram
-   * socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * datagram socket.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, flags, handler);
-  }
-
-  /// Receive a datagram with the endpoint of the sender.
-  /**
-   * This function is used to receive a datagram. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * asio::ip::udp::endpoint sender_endpoint;
-   * socket.receive_from(
-   *     asio::buffer(data, size), sender_endpoint);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-  
-  /// Receive a datagram with the endpoint of the sender.
-  /**
-   * This function is used to receive a datagram. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-  
-  /// Receive a datagram with the endpoint of the sender.
-  /**
-   * This function is used to receive a datagram. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->service.receive_from(this->implementation, buffers,
-        sender_endpoint, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive a datagram. The function
-   * call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.async_receive_from(
-   *     asio::buffer(data, size), 0, sender_endpoint, handler); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, ReadHandler handler)
-  {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, 0, handler);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive a datagram. The function
-   * call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the datagram. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      ReadHandler handler)
-  {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, flags, handler);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_DATAGRAM_SOCKET_HPP

ext/asio/asio/basic_deadline_timer.hpp

@@ -1,442 +0,0 @@
-//
-// basic_deadline_timer.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_DEADLINE_TIMER_HPP
-#define ASIO_BASIC_DEADLINE_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_io_object.hpp"
-#include "asio/deadline_timer_service.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides waitable timer functionality.
-/**
- * The basic_deadline_timer class template provides the ability to perform a
- * blocking or asynchronous wait for a timer to expire.
- *
- * A deadline timer is always in one of two states: "expired" or "not expired".
- * If the wait() or async_wait() function is called on an expired timer, the
- * wait operation will complete immediately.
- *
- * Most applications will use the asio::deadline_timer typedef.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Examples
- * Performing a blocking wait:
- * @code
- * // Construct a timer without setting an expiry time.
- * asio::deadline_timer timer(io_service);
- *
- * // Set an expiry time relative to now.
- * timer.expires_from_now(boost::posix_time::seconds(5));
- *
- * // Wait for the timer to expire.
- * timer.wait();
- * @endcode
- *
- * @par 
- * Performing an asynchronous wait:
- * @code
- * void handler(const asio::error_code& error)
- * {
- *   if (!error)
- *   {
- *     // Timer expired.
- *   }
- * }
- *
- * ...
- *
- * // Construct a timer with an absolute expiry time.
- * asio::deadline_timer timer(io_service,
- *     boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
- *
- * // Start an asynchronous wait.
- * timer.async_wait(handler);
- * @endcode
- *
- * @par Changing an active deadline_timer's expiry time
- *
- * Changing the expiry time of a timer while there are pending asynchronous
- * waits causes those wait operations to be cancelled. To ensure that the action
- * associated with the timer is performed only once, use something like this:
- * used:
- *
- * @code
- * void on_some_event()
- * {
- *   if (my_timer.expires_from_now(seconds(5)) > 0)
- *   {
- *     // We managed to cancel the timer. Start new asynchronous wait.
- *     my_timer.async_wait(on_timeout);
- *   }
- *   else
- *   {
- *     // Too late, timer has already expired!
- *   }
- * }
- *
- * void on_timeout(const asio::error_code& e)
- * {
- *   if (e != asio::error::operation_aborted)
- *   {
- *     // Timer was not cancelled, take necessary action.
- *   }
- * }
- * @endcode
- *
- * @li The asio::basic_deadline_timer::expires_from_now() function
- * cancels any pending asynchronous waits, and returns the number of
- * asynchronous waits that were cancelled. If it returns 0 then you were too
- * late and the wait handler has already been executed, or will soon be
- * executed. If it returns 1 then the wait handler was successfully cancelled.
- *
- * @li If a wait handler is cancelled, the asio::error_code passed to
- * it contains the value asio::error::operation_aborted.
- */
-template <typename Time,
-    typename TimeTraits = asio::time_traits<Time>,
-    typename TimerService = deadline_timer_service<Time, TimeTraits> >
-class basic_deadline_timer
-  : public basic_io_object<TimerService>
-{
-public:
-  /// The time traits type.
-  typedef TimeTraits traits_type;
-
-  /// The time type.
-  typedef typename traits_type::time_type time_type;
-
-  /// The duration type.
-  typedef typename traits_type::duration_type duration_type;
-
-  /// Constructor.
-  /**
-   * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_from_now() functions must be called to set an
-   * expiry time before the timer can be waited on.
-   *
-   * @param io_service The io_service object that the timer will use to dispatch
-   * handlers for any asynchronous operations performed on the timer.
-   */
-  explicit basic_deadline_timer(asio::io_service& io_service)
-    : basic_io_object<TimerService>(io_service)
-  {
-  }
-
-  /// Constructor to set a particular expiry time as an absolute time.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param io_service The io_service object that the timer will use to dispatch
-   * handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, expressed
-   * as an absolute time.
-   */
-  basic_deadline_timer(asio::io_service& io_service,
-      const time_type& expiry_time)
-    : basic_io_object<TimerService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.expires_at(this->implementation, expiry_time, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Constructor to set a particular expiry time relative to now.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param io_service The io_service object that the timer will use to dispatch
-   * handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, relative to
-   * now.
-   */
-  basic_deadline_timer(asio::io_service& io_service,
-      const duration_type& expiry_time)
-    : basic_io_object<TimerService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.expires_from_now(this->implementation, expiry_time, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel()
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.cancel(this->implementation, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel(asio::error_code& ec)
-  {
-    return this->service.cancel(this->implementation, ec);
-  }
-
-  /// Get the timer's expiry time as an absolute time.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  time_type expires_at() const
-  {
-    return this->service.expires_at(this->implementation);
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_type& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.expires_at(
-        this->implementation, expiry_time, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_type& expiry_time,
-      asio::error_code& ec)
-  {
-    return this->service.expires_at(this->implementation, expiry_time, ec);
-  }
-
-  /// Get the timer's expiry time relative to now.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  duration_type expires_from_now() const
-  {
-    return this->service.expires_from_now(this->implementation);
-  }
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration_type& expiry_time)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration_type& expiry_time,
-      asio::error_code& ec)
-  {
-    return this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void wait()
-  {
-    asio::error_code ec;
-    this->service.wait(this->implementation, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  void wait(asio::error_code& ec)
-  {
-    this->service.wait(this->implementation, ec);
-  }
-
-  /// Start an asynchronous wait on the timer.
-  /**
-   * This function may be used to initiate an asynchronous wait against the
-   * timer. It always returns immediately.
-   *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
-   *
-   * @li The timer has expired.
-   *
-   * @li The timer was cancelled, in which case the handler is passed the error
-   * code asio::error::operation_aborted.
-   *
-   * @param handler The handler to be called when the timer expires. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   */
-  template <typename WaitHandler>
-  void async_wait(WaitHandler handler)
-  {
-    this->service.async_wait(this->implementation, handler);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_DEADLINE_TIMER_HPP

ext/asio/asio/basic_io_object.hpp

@@ -1,98 +0,0 @@
-//
-// basic_io_object.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_IO_OBJECT_HPP
-#define ASIO_BASIC_IO_OBJECT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Base class for all I/O objects.
-template <typename IoObjectService>
-class basic_io_object
-  : private noncopyable
-{
-public:
-  /// The type of the service that will be used to provide I/O operations.
-  typedef IoObjectService service_type;
-
-  /// The underlying implementation type of I/O object.
-  typedef typename service_type::implementation_type implementation_type;
-
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  /**
-   * This function may be used to obtain the io_service object that the I/O
-   * object uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_service object that the I/O object will use
-   * to dispatch handlers. Ownership is not transferred to the caller.
-   */
-  asio::io_service& io_service()
-  {
-    return service.get_io_service();
-  }
-
-  /// Get the io_service associated with the object.
-  /**
-   * This function may be used to obtain the io_service object that the I/O
-   * object uses to dispatch handlers for asynchronous operations.
-   *
-   * @return A reference to the io_service object that the I/O object will use
-   * to dispatch handlers. Ownership is not transferred to the caller.
-   */
-  asio::io_service& get_io_service()
-  {
-    return service.get_io_service();
-  }
-
-protected:
-  /// Construct a basic_io_object.
-  /**
-   * Performs:
-   * @code service.construct(implementation); @endcode
-   */
-  explicit basic_io_object(asio::io_service& io_service)
-    : service(asio::use_service<IoObjectService>(io_service))
-  {
-    service.construct(implementation);
-  }
-
-  /// Protected destructor to prevent deletion through this type.
-  /**
-   * Performs:
-   * @code service.destroy(implementation); @endcode
-   */
-  ~basic_io_object()
-  {
-    service.destroy(implementation);
-  }
-
-  /// The service associated with the I/O object.
-  service_type& service;
-
-  /// The underlying implementation of the I/O object.
-  implementation_type implementation;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_IO_OBJECT_HPP

ext/asio/asio/basic_raw_socket.hpp

@@ -1,795 +0,0 @@
-//
-// basic_raw_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_RAW_SOCKET_HPP
-#define ASIO_BASIC_RAW_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_socket.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/raw_socket_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides raw-oriented socket functionality.
-/**
- * The basic_raw_socket class template provides asynchronous and blocking
- * raw-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Protocol,
-    typename RawSocketService = raw_socket_service<Protocol> >
-class basic_raw_socket
-  : public basic_socket<Protocol, RawSocketService>
-{
-public:
-  /// The native representation of a socket.
-  typedef typename RawSocketService::native_type native_type;
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_raw_socket without opening it.
-  /**
-   * This constructor creates a raw socket without opening it. The open()
-   * function must be called before data can be sent or received on the socket.
-   *
-   * @param io_service The io_service object that the raw socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   */
-  explicit basic_raw_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, RawSocketService>(io_service)
-  {
-  }
-
-  /// Construct and open a basic_raw_socket.
-  /**
-   * This constructor creates and opens a raw socket.
-   *
-   * @param io_service The io_service object that the raw socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_raw_socket(asio::io_service& io_service,
-      const protocol_type& protocol)
-    : basic_socket<Protocol, RawSocketService>(io_service, protocol)
-  {
-  }
-
-  /// Construct a basic_raw_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a raw socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param io_service The io_service object that the raw socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the raw
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_raw_socket(asio::io_service& io_service,
-      const endpoint_type& endpoint)
-    : basic_socket<Protocol, RawSocketService>(io_service, endpoint)
-  {
-  }
-
-  /// Construct a basic_raw_socket on an existing native socket.
-  /**
-   * This constructor creates a raw socket object to hold an existing
-   * native socket.
-   *
-   * @param io_service The io_service object that the raw socket will use
-   * to dispatch handlers for any asynchronous operations performed on the
-   * socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_raw_socket(asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
-    : basic_socket<Protocol, RawSocketService>(
-        io_service, protocol, native_socket)
-  {
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected raw socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code socket.send(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One ore more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected raw socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send some data on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @note The send operation can only be used with a connected socket. Use
-   * the send_to function to send data on an unconnected raw socket.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->service.send(this->implementation, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected raw
-   * socket.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers, WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, 0, handler);
-  }
-
-  /// Start an asynchronous send on a connected socket.
-  /**
-   * This function is used to send data on the raw socket. The function call
-   * will block until the data has been sent successfully or an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_send operation can only be used with a connected socket.
-   * Use the async_send_to function to send data on an unconnected raw
-   * socket.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, flags, handler);
-  }
-
-  /// Send raw data to the specified endpoint.
-  /**
-   * This function is used to send raw data to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.send_to(asio::buffer(data, size), destination);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send raw data to the specified endpoint.
-  /**
-   * This function is used to send raw data to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send_to(
-        this->implementation, buffers, destination, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send raw data to the specified endpoint.
-  /**
-   * This function is used to send raw data to the specified remote endpoint.
-   * The function call will block until the data has been sent successfully or
-   * an error occurs.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->service.send_to(this->implementation,
-        buffers, destination, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * asio::ip::udp::endpoint destination(
-   *     asio::ip::address::from_string("1.2.3.4"), 12345);
-   * socket.async_send_to(
-   *     asio::buffer(data, size), destination, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, WriteHandler handler)
-  {
-    this->service.async_send_to(this->implementation, buffers, destination, 0,
-        handler);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send raw data to the specified
-   * remote endpoint. The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent to the remote endpoint.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param destination The remote endpoint to which the data will be sent.
-   * Copies will be made of the endpoint as required.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
-      const endpoint_type& destination, socket_base::message_flags flags,
-      WriteHandler handler)
-  {
-    this->service.async_send_to(this->implementation, buffers, destination,
-        flags, handler);
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the raw socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected raw
-   * socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.receive(asio::buffer(data, size)); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the raw socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected raw
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the raw socket. The function
-   * call will block until data has been received successfully or an error
-   * occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   *
-   * @note The receive operation can only be used with a connected socket. Use
-   * the receive_from function to receive data on an unconnected raw
-   * socket.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->service.receive(this->implementation, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the raw
-   * socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * raw socket.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers, ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
-  }
-
-  /// Start an asynchronous receive on a connected socket.
-  /**
-   * This function is used to asynchronously receive data from the raw
-   * socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The async_receive operation can only be used with a connected socket.
-   * Use the async_receive_from function to receive data on an unconnected
-   * raw socket.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, flags, handler);
-  }
-
-  /// Receive raw data with the endpoint of the sender.
-  /**
-   * This function is used to receive raw data. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * asio::ip::udp::endpoint sender_endpoint;
-   * socket.receive_from(
-   *     asio::buffer(data, size), sender_endpoint);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-  
-  /// Receive raw data with the endpoint of the sender.
-  /**
-   * This function is used to receive raw data. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive_from(
-        this->implementation, buffers, sender_endpoint, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-  
-  /// Receive raw data with the endpoint of the sender.
-  /**
-   * This function is used to receive raw data. The function call will block
-   * until data has been received successfully or an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      asio::error_code& ec)
-  {
-    return this->service.receive_from(this->implementation, buffers,
-        sender_endpoint, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive raw data. The function
-   * call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code socket.async_receive_from(
-   *     asio::buffer(data, size), 0, sender_endpoint, handler); @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, ReadHandler handler)
-  {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, 0, handler);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive raw data. The function
-   * call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param sender_endpoint An endpoint object that receives the endpoint of
-   * the remote sender of the data. Ownership of the sender_endpoint object
-   * is retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
-      endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      ReadHandler handler)
-  {
-    this->service.async_receive_from(this->implementation, buffers,
-        sender_endpoint, flags, handler);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_RAW_SOCKET_HPP

ext/asio/asio/basic_serial_port.hpp

@@ -1,620 +0,0 @@
-//
-// basic_serial_port.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SERIAL_PORT_HPP
-#define ASIO_BASIC_SERIAL_PORT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <string>
-#include "asio/basic_io_object.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/serial_port_base.hpp"
-#include "asio/serial_port_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides serial port functionality.
-/**
- * The basic_serial_port class template provides functionality that is common
- * to all serial ports.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename SerialPortService = serial_port_service>
-class basic_serial_port
-  : public basic_io_object<SerialPortService>,
-    public serial_port_base
-{
-public:
-  /// The native representation of a serial port.
-  typedef typename SerialPortService::native_type native_type;
-
-  /// A basic_serial_port is always the lowest layer.
-  typedef basic_serial_port<SerialPortService> lowest_layer_type;
-
-  /// Construct a basic_serial_port without opening it.
-  /**
-   * This constructor creates a serial port without opening it.
-   *
-   * @param io_service The io_service object that the serial port will use to
-   * dispatch handlers for any asynchronous operations performed on the port.
-   */
-  explicit basic_serial_port(asio::io_service& io_service)
-    : basic_io_object<SerialPortService>(io_service)
-  {
-  }
-
-  /// Construct and open a basic_serial_port.
-  /**
-   * This constructor creates and opens a serial port for the specified device
-   * name.
-   *
-   * @param io_service The io_service object that the serial port will use to
-   * dispatch handlers for any asynchronous operations performed on the port.
-   *
-   * @param device The platform-specific device name for this serial
-   * port.
-   */
-  explicit basic_serial_port(asio::io_service& io_service,
-      const char* device)
-    : basic_io_object<SerialPortService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.open(this->implementation, device, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Construct and open a basic_serial_port.
-  /**
-   * This constructor creates and opens a serial port for the specified device
-   * name.
-   *
-   * @param io_service The io_service object that the serial port will use to
-   * dispatch handlers for any asynchronous operations performed on the port.
-   *
-   * @param device The platform-specific device name for this serial
-   * port.
-   */
-  explicit basic_serial_port(asio::io_service& io_service,
-      const std::string& device)
-    : basic_io_object<SerialPortService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.open(this->implementation, device, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Construct a basic_serial_port on an existing native serial port.
-  /**
-   * This constructor creates a serial port object to hold an existing native
-   * serial port.
-   *
-   * @param io_service The io_service object that the serial port will use to
-   * dispatch handlers for any asynchronous operations performed on the port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_serial_port(asio::io_service& io_service,
-      const native_type& native_serial_port)
-    : basic_io_object<SerialPortService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.assign(this->implementation, native_serial_port, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Get a reference to the lowest layer.
-  /**
-   * This function returns a reference to the lowest layer in a stack of
-   * layers. Since a basic_serial_port cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A reference to the lowest layer in the stack of layers. Ownership
-   * is not transferred to the caller.
-   */
-  lowest_layer_type& lowest_layer()
-  {
-    return *this;
-  }
-
-  /// Get a const reference to the lowest layer.
-  /**
-   * This function returns a const reference to the lowest layer in a stack of
-   * layers. Since a basic_serial_port cannot contain any further layers, it
-   * simply returns a reference to itself.
-   *
-   * @return A const reference to the lowest layer in the stack of layers.
-   * Ownership is not transferred to the caller.
-   */
-  const lowest_layer_type& lowest_layer() const
-  {
-    return *this;
-  }
-
-  /// Open the serial port using the specified device name.
-  /**
-   * This function opens the serial port for the specified device name.
-   *
-   * @param device The platform-specific device name.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void open(const std::string& device)
-  {
-    asio::error_code ec;
-    this->service.open(this->implementation, device, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Open the serial port using the specified device name.
-  /**
-   * This function opens the serial port using the given platform-specific
-   * device name.
-   *
-   * @param device The platform-specific device name.
-   *
-   * @param ec Set the indicate what error occurred, if any.
-   */
-  asio::error_code open(const std::string& device,
-      asio::error_code& ec)
-  {
-    return this->service.open(this->implementation, device, ec);
-  }
-
-  /// Assign an existing native serial port to the serial port.
-  /*
-   * This function opens the serial port to hold an existing native serial port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const native_type& native_serial_port)
-  {
-    asio::error_code ec;
-    this->service.assign(this->implementation, native_serial_port, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Assign an existing native serial port to the serial port.
-  /*
-   * This function opens the serial port to hold an existing native serial port.
-   *
-   * @param native_serial_port A native serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code assign(const native_type& native_serial_port,
-      asio::error_code& ec)
-  {
-    return this->service.assign(this->implementation, native_serial_port, ec);
-  }
-
-  /// Determine whether the serial port is open.
-  bool is_open() const
-  {
-    return this->service.is_open(this->implementation);
-  }
-
-  /// Close the serial port.
-  /**
-   * This function is used to close the serial port. Any asynchronous read or
-   * write operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    this->service.close(this->implementation, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Close the serial port.
-  /**
-   * This function is used to close the serial port. Any asynchronous read or
-   * write operations will be cancelled immediately, and will complete with the
-   * asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code close(asio::error_code& ec)
-  {
-    return this->service.close(this->implementation, ec);
-  }
-
-  /// Get the native serial port representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * serial port. This is intended to allow access to native serial port
-   * functionality that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->service.native(this->implementation);
-  }
-
-  /// Cancel all asynchronous operations associated with the serial port.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Cancel all asynchronous operations associated with the serial port.
-  /**
-   * This function causes all outstanding asynchronous read or write operations
-   * to finish immediately, and the handlers for cancelled operations will be
-   * passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code cancel(asio::error_code& ec)
-  {
-    return this->service.cancel(this->implementation, ec);
-  }
-
-  /// Send a break sequence to the serial port.
-  /**
-   * This function causes a break sequence of platform-specific duration to be
-   * sent out the serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void send_break()
-  {
-    asio::error_code ec;
-    this->service.send_break(this->implementation, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Send a break sequence to the serial port.
-  /**
-   * This function causes a break sequence of platform-specific duration to be
-   * sent out the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code send_break(asio::error_code& ec)
-  {
-    return this->service.send_break(this->implementation, ec);
-  }
-
-  /// Set an option on the serial port.
-  /**
-   * This function is used to set an option on the serial port.
-   *
-   * @param option The option value to be set on the serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa SettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename SettableSerialPortOption>
-  void set_option(const SettableSerialPortOption& option)
-  {
-    asio::error_code ec;
-    this->service.set_option(this->implementation, option, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Set an option on the serial port.
-  /**
-   * This function is used to set an option on the serial port.
-   *
-   * @param option The option value to be set on the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa SettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename SettableSerialPortOption>
-  asio::error_code set_option(const SettableSerialPortOption& option,
-      asio::error_code& ec)
-  {
-    return this->service.set_option(this->implementation, option, ec);
-  }
-
-  /// Get an option from the serial port.
-  /**
-   * This function is used to get the current value of an option on the serial
-   * port.
-   *
-   * @param option The option value to be obtained from the serial port.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa GettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename GettableSerialPortOption>
-  void get_option(GettableSerialPortOption& option)
-  {
-    asio::error_code ec;
-    this->service.get_option(this->implementation, option, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Get an option from the serial port.
-  /**
-   * This function is used to get the current value of an option on the serial
-   * port.
-   *
-   * @param option The option value to be obtained from the serial port.
-   *
-   * @param ec Set to indicate what error occured, if any.
-   *
-   * @sa GettableSerialPortOption @n
-   * asio::serial_port_base::baud_rate @n
-   * asio::serial_port_base::flow_control @n
-   * asio::serial_port_base::parity @n
-   * asio::serial_port_base::stop_bits @n
-   * asio::serial_port_base::character_size
-   */
-  template <typename GettableSerialPortOption>
-  asio::error_code get_option(GettableSerialPortOption& option,
-      asio::error_code& ec)
-  {
-    return this->service.get_option(this->implementation, option, ec);
-  }
-
-  /// Write some data to the serial port.
-  /**
-   * This function is used to write data to the serial port. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the serial port.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * serial_port.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Write some data to the serial port.
-  /**
-   * This function is used to write data to the serial port. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the serial port.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->service.write_some(this->implementation, buffers, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the serial port.
-   * The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the serial port.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * serial_port.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    this->service.async_write_some(this->implementation, buffers, handler);
-  }
-
-  /// Read some data from the serial port.
-  /**
-   * This function is used to read data from the serial port. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * serial_port.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Read some data from the serial port.
-  /**
-   * This function is used to read data from the serial port. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->service.read_some(this->implementation, buffers, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the serial port.
-   * The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * serial_port.async_read_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    this->service.async_read_some(this->implementation, buffers, handler);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // ASIO_BASIC_SERIAL_PORT_HPP

ext/asio/asio/basic_socket_acceptor.hpp

@@ -1,825 +0,0 @@
-//
-// basic_socket_acceptor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_ACCEPTOR_HPP
-#define ASIO_BASIC_SOCKET_ACCEPTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/basic_io_object.hpp"
-#include "asio/basic_socket.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/socket_acceptor_service.hpp"
-#include "asio/socket_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides the ability to accept new connections.
-/**
- * The basic_socket_acceptor class template is used for accepting new socket
- * connections.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Example
- * Opening a socket acceptor with the SO_REUSEADDR option enabled:
- * @code
- * asio::ip::tcp::acceptor acceptor(io_service);
- * asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);
- * acceptor.open(endpoint.protocol());
- * acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));
- * acceptor.bind(endpoint);
- * acceptor.listen();
- * @endcode
- */
-template <typename Protocol,
-    typename SocketAcceptorService = socket_acceptor_service<Protocol> >
-class basic_socket_acceptor
-  : public basic_io_object<SocketAcceptorService>,
-    public socket_base
-{
-public:
-  /// The native representation of an acceptor.
-  typedef typename SocketAcceptorService::native_type native_type;
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct an acceptor without opening it.
-  /**
-   * This constructor creates an acceptor without opening it to listen for new
-   * connections. The open() function must be called before the acceptor can
-   * accept new socket connections.
-   *
-   * @param io_service The io_service object that the acceptor will use to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   */
-  explicit basic_socket_acceptor(asio::io_service& io_service)
-    : basic_io_object<SocketAcceptorService>(io_service)
-  {
-  }
-
-  /// Construct an open acceptor.
-  /**
-   * This constructor creates an acceptor and automatically opens it.
-   *
-   * @param io_service The io_service object that the acceptor will use to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket_acceptor(asio::io_service& io_service,
-      const protocol_type& protocol)
-    : basic_io_object<SocketAcceptorService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.open(this->implementation, protocol, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Construct an acceptor opened on the given endpoint.
-  /**
-   * This constructor creates an acceptor and automatically opens it to listen
-   * for new connections on the specified endpoint.
-   *
-   * @param io_service The io_service object that the acceptor will use to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   *
-   * @param endpoint An endpoint on the local machine on which the acceptor
-   * will listen for new connections.
-   *
-   * @param reuse_addr Whether the constructor should set the socket option
-   * socket_base::reuse_address.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note This constructor is equivalent to the following code:
-   * @code
-   * basic_socket_acceptor<Protocol> acceptor(io_service);
-   * acceptor.open(endpoint.protocol());
-   * if (reuse_addr)
-   *   acceptor.set_option(socket_base::reuse_address(true));
-   * acceptor.bind(endpoint);
-   * acceptor.listen(listen_backlog);
-   * @endcode
-   */
-  basic_socket_acceptor(asio::io_service& io_service,
-      const endpoint_type& endpoint, bool reuse_addr = true)
-    : basic_io_object<SocketAcceptorService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.open(this->implementation, endpoint.protocol(), ec);
-    asio::detail::throw_error(ec);
-    if (reuse_addr)
-    {
-      this->service.set_option(this->implementation,
-          socket_base::reuse_address(true), ec);
-      asio::detail::throw_error(ec);
-    }
-    this->service.bind(this->implementation, endpoint, ec);
-    asio::detail::throw_error(ec);
-    this->service.listen(this->implementation,
-        socket_base::max_connections, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Construct a basic_socket_acceptor on an existing native acceptor.
-  /**
-   * This constructor creates an acceptor object to hold an existing native
-   * acceptor.
-   *
-   * @param io_service The io_service object that the acceptor will use to
-   * dispatch handlers for any asynchronous operations performed on the
-   * acceptor.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_socket_acceptor(asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_acceptor)
-    : basic_io_object<SocketAcceptorService>(io_service)
-  {
-    asio::error_code ec;
-    this->service.assign(this->implementation, protocol, native_acceptor, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Open the acceptor using the specified protocol.
-  /**
-   * This function opens the socket acceptor so that it will use the specified
-   * protocol.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * acceptor.open(asio::ip::tcp::v4());
-   * @endcode
-   */
-  void open(const protocol_type& protocol = protocol_type())
-  {
-    asio::error_code ec;
-    this->service.open(this->implementation, protocol, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Open the acceptor using the specified protocol.
-  /**
-   * This function opens the socket acceptor so that it will use the specified
-   * protocol.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * asio::error_code ec;
-   * acceptor.open(asio::ip::tcp::v4(), ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  asio::error_code open(const protocol_type& protocol,
-      asio::error_code& ec)
-  {
-    return this->service.open(this->implementation, protocol, ec);
-  }
-
-  /// Assigns an existing native acceptor to the acceptor.
-  /*
-   * This function opens the acceptor to hold an existing native acceptor.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void assign(const protocol_type& protocol, const native_type& native_acceptor)
-  {
-    asio::error_code ec;
-    this->service.assign(this->implementation, protocol, native_acceptor, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Assigns an existing native acceptor to the acceptor.
-  /*
-   * This function opens the acceptor to hold an existing native acceptor.
-   *
-   * @param protocol An object specifying which protocol is to be used.
-   *
-   * @param native_acceptor A native acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code assign(const protocol_type& protocol,
-      const native_type& native_acceptor, asio::error_code& ec)
-  {
-    return this->service.assign(this->implementation,
-        protocol, native_acceptor, ec);
-  }
-
-  /// Determine whether the acceptor is open.
-  bool is_open() const
-  {
-    return this->service.is_open(this->implementation);
-  }
-
-  /// Bind the acceptor to the given local endpoint.
-  /**
-   * This function binds the socket acceptor to the specified endpoint on the
-   * local machine.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket
-   * acceptor will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * acceptor.open(asio::ip::tcp::v4());
-   * acceptor.bind(asio::ip::tcp::endpoint(12345));
-   * @endcode
-   */
-  void bind(const endpoint_type& endpoint)
-  {
-    asio::error_code ec;
-    this->service.bind(this->implementation, endpoint, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Bind the acceptor to the given local endpoint.
-  /**
-   * This function binds the socket acceptor to the specified endpoint on the
-   * local machine.
-   *
-   * @param endpoint An endpoint on the local machine to which the socket
-   * acceptor will be bound.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * acceptor.open(asio::ip::tcp::v4());
-   * asio::error_code ec;
-   * acceptor.bind(asio::ip::tcp::endpoint(12345), ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  asio::error_code bind(const endpoint_type& endpoint,
-      asio::error_code& ec)
-  {
-    return this->service.bind(this->implementation, endpoint, ec);
-  }
-
-  /// Place the acceptor into the state where it will listen for new
-  /// connections.
-  /**
-   * This function puts the socket acceptor into the state where it may accept
-   * new connections.
-   *
-   * @param backlog The maximum length of the queue of pending connections.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void listen(int backlog = socket_base::max_connections)
-  {
-    asio::error_code ec;
-    this->service.listen(this->implementation, backlog, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Place the acceptor into the state where it will listen for new
-  /// connections.
-  /**
-   * This function puts the socket acceptor into the state where it may accept
-   * new connections.
-   *
-   * @param backlog The maximum length of the queue of pending connections.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::error_code ec;
-   * acceptor.listen(asio::socket_base::max_connections, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  asio::error_code listen(int backlog, asio::error_code& ec)
-  {
-    return this->service.listen(this->implementation, backlog, ec);
-  }
-
-  /// Close the acceptor.
-  /**
-   * This function is used to close the acceptor. Any asynchronous accept
-   * operations will be cancelled immediately.
-   *
-   * A subsequent call to open() is required before the acceptor can again be
-   * used to again perform socket accept operations.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void close()
-  {
-    asio::error_code ec;
-    this->service.close(this->implementation, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Close the acceptor.
-  /**
-   * This function is used to close the acceptor. Any asynchronous accept
-   * operations will be cancelled immediately.
-   *
-   * A subsequent call to open() is required before the acceptor can again be
-   * used to again perform socket accept operations.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::error_code ec;
-   * acceptor.close(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  asio::error_code close(asio::error_code& ec)
-  {
-    return this->service.close(this->implementation, ec);
-  }
-
-  /// Get the native acceptor representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * acceptor. This is intended to allow access to native acceptor functionality
-   * that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->service.native(this->implementation);
-  }
-
-  /// Cancel all asynchronous operations associated with the acceptor.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  void cancel()
-  {
-    asio::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Cancel all asynchronous operations associated with the acceptor.
-  /**
-   * This function causes all outstanding asynchronous connect, send and receive
-   * operations to finish immediately, and the handlers for cancelled operations
-   * will be passed the asio::error::operation_aborted error.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  asio::error_code cancel(asio::error_code& ec)
-  {
-    return this->service.cancel(this->implementation, ec);
-  }
-
-  /// Set an option on the acceptor.
-  /**
-   * This function is used to set an option on the acceptor.
-   *
-   * @param option The new option value to be set on the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa SettableSocketOption @n
-   * asio::socket_base::reuse_address
-   * asio::socket_base::enable_connection_aborted
-   *
-   * @par Example
-   * Setting the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option(true);
-   * acceptor.set_option(option);
-   * @endcode
-   */
-  template <typename SettableSocketOption>
-  void set_option(const SettableSocketOption& option)
-  {
-    asio::error_code ec;
-    this->service.set_option(this->implementation, option, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Set an option on the acceptor.
-  /**
-   * This function is used to set an option on the acceptor.
-   *
-   * @param option The new option value to be set on the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa SettableSocketOption @n
-   * asio::socket_base::reuse_address
-   * asio::socket_base::enable_connection_aborted
-   *
-   * @par Example
-   * Setting the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option(true);
-   * asio::error_code ec;
-   * acceptor.set_option(option, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename SettableSocketOption>
-  asio::error_code set_option(const SettableSocketOption& option,
-      asio::error_code& ec)
-  {
-    return this->service.set_option(this->implementation, option, ec);
-  }
-
-  /// Get an option from the acceptor.
-  /**
-   * This function is used to get the current value of an option on the
-   * acceptor.
-   *
-   * @param option The option value to be obtained from the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @sa GettableSocketOption @n
-   * asio::socket_base::reuse_address
-   *
-   * @par Example
-   * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option;
-   * acceptor.get_option(option);
-   * bool is_set = option.get();
-   * @endcode
-   */
-  template <typename GettableSocketOption>
-  void get_option(GettableSocketOption& option)
-  {
-    asio::error_code ec;
-    this->service.get_option(this->implementation, option, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Get an option from the acceptor.
-  /**
-   * This function is used to get the current value of an option on the
-   * acceptor.
-   *
-   * @param option The option value to be obtained from the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa GettableSocketOption @n
-   * asio::socket_base::reuse_address
-   *
-   * @par Example
-   * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::acceptor::reuse_address option;
-   * asio::error_code ec;
-   * acceptor.get_option(option, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * bool is_set = option.get();
-   * @endcode
-   */
-  template <typename GettableSocketOption>
-  asio::error_code get_option(GettableSocketOption& option,
-      asio::error_code& ec)
-  {
-    return this->service.get_option(this->implementation, option, ec);
-  }
-
-  /// Get the local endpoint of the acceptor.
-  /**
-   * This function is used to obtain the locally bound endpoint of the acceptor.
-   *
-   * @returns An object that represents the local endpoint of the acceptor.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();
-   * @endcode
-   */
-  endpoint_type local_endpoint() const
-  {
-    asio::error_code ec;
-    endpoint_type ep = this->service.local_endpoint(this->implementation, ec);
-    asio::detail::throw_error(ec);
-    return ep;
-  }
-
-  /// Get the local endpoint of the acceptor.
-  /**
-   * This function is used to obtain the locally bound endpoint of the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns An object that represents the local endpoint of the acceptor.
-   * Returns a default-constructed endpoint object if an error occurred and the
-   * error handler did not throw an exception.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::error_code ec;
-   * asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  endpoint_type local_endpoint(asio::error_code& ec) const
-  {
-    return this->service.local_endpoint(this->implementation, ec);
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket. The function call will block until a new connection has been
-   * accepted successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::socket socket(io_service);
-   * acceptor.accept(socket);
-   * @endcode
-   */
-  template <typename SocketService>
-  void accept(basic_socket<protocol_type, SocketService>& peer)
-  {
-    asio::error_code ec;
-    this->service.accept(this->implementation, peer, 0, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Accept a new connection.
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket. The function call will block until a new connection has been
-   * accepted successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::soocket socket(io_service);
-   * asio::error_code ec;
-   * acceptor.accept(socket, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename SocketService>
-  asio::error_code accept(
-      basic_socket<protocol_type, SocketService>& peer,
-      asio::error_code& ec)
-  {
-    return this->service.accept(this->implementation, peer, 0, ec);
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection into a
-   * socket. The function call always returns immediately.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   * Ownership of the peer object is retained by the caller, which must
-   * guarantee that it is valid until the handler is called.
-   *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @par Example
-   * @code
-   * void accept_handler(const asio::error_code& error)
-   * {
-   *   if (!error)
-   *   {
-   *     // Accept succeeded.
-   *   }
-   * }
-   *
-   * ...
-   *
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::socket socket(io_service);
-   * acceptor.async_accept(socket, accept_handler);
-   * @endcode
-   */
-  template <typename SocketService, typename AcceptHandler>
-  void async_accept(basic_socket<protocol_type, SocketService>& peer,
-      AcceptHandler handler)
-  {
-    this->service.async_accept(this->implementation, peer, 0, handler);
-  }
-
-  /// Accept a new connection and obtain the endpoint of the peer
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket, and additionally provide the endpoint of the remote peer.
-   * The function call will block until a new connection has been accepted
-   * successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @param peer_endpoint An endpoint object which will receive the endpoint of
-   * the remote peer.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::socket socket(io_service);
-   * asio::ip::tcp::endpoint endpoint;
-   * acceptor.accept(socket, endpoint);
-   * @endcode
-   */
-  template <typename SocketService>
-  void accept(basic_socket<protocol_type, SocketService>& peer,
-      endpoint_type& peer_endpoint)
-  {
-    asio::error_code ec;
-    this->service.accept(this->implementation, peer, &peer_endpoint, ec);
-    asio::detail::throw_error(ec);
-  }
-
-  /// Accept a new connection and obtain the endpoint of the peer
-  /**
-   * This function is used to accept a new connection from a peer into the
-   * given socket, and additionally provide the endpoint of the remote peer.
-   * The function call will block until a new connection has been accepted
-   * successfully or an error occurs.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   *
-   * @param peer_endpoint An endpoint object which will receive the endpoint of
-   * the remote peer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @par Example
-   * @code
-   * asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * asio::ip::tcp::socket socket(io_service);
-   * asio::ip::tcp::endpoint endpoint;
-   * asio::error_code ec;
-   * acceptor.accept(socket, endpoint, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename SocketService>
-  asio::error_code accept(
-      basic_socket<protocol_type, SocketService>& peer,
-      endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    return this->service.accept(this->implementation, peer, &peer_endpoint, ec);
-  }
-
-  /// Start an asynchronous accept.
-  /**
-   * This function is used to asynchronously accept a new connection into a
-   * socket, and additionally obtain the endpoint of the remote peer. The
-   * function call always returns immediately.
-   *
-   * @param peer The socket into which the new connection will be accepted.
-   * Ownership of the peer object is retained by the caller, which must
-   * guarantee that it is valid until the handler is called.
-   *
-   * @param peer_endpoint An endpoint object into which the endpoint of the
-   * remote peer will be written. Ownership of the peer_endpoint object is
-   * retained by the caller, which must guarantee that it is valid until the
-   * handler is called.
-   *
-   * @param handler The handler to be called when the accept operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error // Result of operation.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   */
-  template <typename SocketService, typename AcceptHandler>
-  void async_accept(basic_socket<protocol_type, SocketService>& peer,
-      endpoint_type& peer_endpoint, AcceptHandler handler)
-  {
-    this->service.async_accept(this->implementation,
-        peer, &peer_endpoint, handler);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_SOCKET_ACCEPTOR_HPP

ext/asio/asio/basic_socket_iostream.hpp

@@ -1,151 +0,0 @@
-//
-// basic_socket_iostream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_IOSTREAM_HPP
-#define ASIO_BASIC_SOCKET_IOSTREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/utility/base_from_member.hpp>
-#include "asio/basic_socket_streambuf.hpp"
-#include "asio/stream_socket_service.hpp"
-
-#if !defined(ASIO_SOCKET_IOSTREAM_MAX_ARITY)
-#define ASIO_SOCKET_IOSTREAM_MAX_ARITY 5
-#endif // !defined(ASIO_SOCKET_IOSTREAM_MAX_ARITY)
-
-// A macro that should expand to:
-//   template <typename T1, ..., typename Tn>
-//   explicit basic_socket_iostream(T1 x1, ..., Tn xn)
-//     : basic_iostream<char>(&this->boost::base_from_member<
-//         basic_socket_streambuf<Protocol, StreamSocketService> >::member)
-//   {
-//     if (rdbuf()->connect(x1, ..., xn) == 0)
-//       this->setstate(std::ios_base::failbit);
-//   }
-// This macro should only persist within this file.
-
-#define ASIO_PRIVATE_CTR_DEF(z, n, data) \
-  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  explicit basic_socket_iostream(BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
-    : std::basic_iostream<char>(&this->boost::base_from_member< \
-        basic_socket_streambuf<Protocol, StreamSocketService> >::member) \
-  { \
-    tie(this); \
-    if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 0) \
-      this->setstate(std::ios_base::failbit); \
-  } \
-  /**/
-
-// A macro that should expand to:
-//   template <typename T1, ..., typename Tn>
-//   void connect(T1 x1, ..., Tn xn)
-//   {
-//     if (rdbuf()->connect(x1, ..., xn) == 0)
-//       this->setstate(std::ios_base::failbit);
-//   }
-// This macro should only persist within this file.
-
-#define ASIO_PRIVATE_CONNECT_DEF(z, n, data) \
-  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  void connect(BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
-  { \
-    if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 0) \
-      this->setstate(std::ios_base::failbit); \
-  } \
-  /**/
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Iostream interface for a socket.
-template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol> >
-class basic_socket_iostream
-  : public boost::base_from_member<
-      basic_socket_streambuf<Protocol, StreamSocketService> >,
-    public std::basic_iostream<char>
-{
-public:
-  /// Construct a basic_socket_iostream without establishing a connection.
-  basic_socket_iostream()
-    : std::basic_iostream<char>(&this->boost::base_from_member<
-        basic_socket_streambuf<Protocol, StreamSocketService> >::member)
-  {
-    tie(this);
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// Establish a connection to an endpoint corresponding to a resolver query.
-  /**
-   * This constructor automatically establishes a connection based on the
-   * supplied resolver query parameters. The arguments are used to construct
-   * a resolver query object.
-   */
-  template <typename T1, ..., typename TN>
-  explicit basic_socket_iostream(T1 t1, ..., TN tn);
-#else
-  BOOST_PP_REPEAT_FROM_TO(
-      1, BOOST_PP_INC(ASIO_SOCKET_IOSTREAM_MAX_ARITY),
-      ASIO_PRIVATE_CTR_DEF, _ )
-#endif
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// Establish a connection to an endpoint corresponding to a resolver query.
-  /**
-   * This function automatically establishes a connection based on the supplied
-   * resolver query parameters. The arguments are used to construct a resolver
-   * query object.
-   */
-  template <typename T1, ..., typename TN>
-  void connect(T1 t1, ..., TN tn);
-#else
-  BOOST_PP_REPEAT_FROM_TO(
-      1, BOOST_PP_INC(ASIO_SOCKET_IOSTREAM_MAX_ARITY),
-      ASIO_PRIVATE_CONNECT_DEF, _ )
-#endif
-
-  /// Close the connection.
-  void close()
-  {
-    if (rdbuf()->close() == 0)
-      this->setstate(std::ios_base::failbit);
-  }
-
-  /// Return a pointer to the underlying streambuf.
-  basic_socket_streambuf<Protocol, StreamSocketService>* rdbuf() const
-  {
-    return const_cast<basic_socket_streambuf<Protocol, StreamSocketService>*>(
-        &this->boost::base_from_member<
-          basic_socket_streambuf<Protocol, StreamSocketService> >::member);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#undef ASIO_PRIVATE_CTR_DEF
-#undef ASIO_PRIVATE_CONNECT_DEF
-
-#endif // defined(BOOST_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_SOCKET_IOSTREAM_HPP

ext/asio/asio/basic_socket_streambuf.hpp

@@ -1,290 +0,0 @@
-//
-// basic_socket_streambuf.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_SOCKET_STREAMBUF_HPP
-#define ASIO_BASIC_SOCKET_STREAMBUF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#include <streambuf>
-#include <boost/array.hpp>
-#include <boost/preprocessor/arithmetic/inc.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/utility/base_from_member.hpp>
-#include "asio/basic_socket.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/stream_socket_service.hpp"
-
-#if !defined(ASIO_SOCKET_STREAMBUF_MAX_ARITY)
-#define ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
-#endif // !defined(ASIO_SOCKET_STREAMBUF_MAX_ARITY)
-
-// A macro that should expand to:
-//   template <typename T1, ..., typename Tn>
-//   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
-//       T1 x1, ..., Tn xn)
-//   {
-//     init_buffers();
-//     asio::error_code ec;
-//     this->basic_socket<Protocol, StreamSocketService>::close(ec);
-//     typedef typename Protocol::resolver resolver_type;
-//     typedef typename resolver_type::query resolver_query;
-//     resolver_query query(x1, ..., xn);
-//     resolve_and_connect(query, ec);
-//     return !ec ? this : 0;
-//   }
-// This macro should only persist within this file.
-
-#define ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
-  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  basic_socket_streambuf<Protocol, StreamSocketService>* connect( \
-      BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
-  { \
-    init_buffers(); \
-    asio::error_code ec; \
-    this->basic_socket<Protocol, StreamSocketService>::close(ec); \
-    typedef typename Protocol::resolver resolver_type; \
-    typedef typename resolver_type::query resolver_query; \
-    resolver_query query(BOOST_PP_ENUM_PARAMS(n, x)); \
-    resolve_and_connect(query, ec); \
-    return !ec ? this : 0; \
-  } \
-  /**/
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Iostream streambuf for a socket.
-template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol> >
-class basic_socket_streambuf
-  : public std::streambuf,
-    private boost::base_from_member<io_service>,
-    public basic_socket<Protocol, StreamSocketService>
-{
-public:
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_socket_streambuf without establishing a connection.
-  basic_socket_streambuf()
-    : basic_socket<Protocol, StreamSocketService>(
-        boost::base_from_member<asio::io_service>::member),
-      unbuffered_(false)
-  {
-    init_buffers();
-  }
-
-  /// Destructor flushes buffered data.
-  virtual ~basic_socket_streambuf()
-  {
-    if (pptr() != pbase())
-      overflow(traits_type::eof());
-  }
-
-  /// Establish a connection.
-  /**
-   * This function establishes a connection to the specified endpoint.
-   *
-   * @return \c this if a connection was successfully established, a null
-   * pointer otherwise.
-   */
-  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
-      const endpoint_type& endpoint)
-  {
-    init_buffers();
-    asio::error_code ec;
-    this->basic_socket<Protocol, StreamSocketService>::close(ec);
-    this->basic_socket<Protocol, StreamSocketService>::connect(endpoint, ec);
-    return !ec ? this : 0;
-  }
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// Establish a connection.
-  /**
-   * This function automatically establishes a connection based on the supplied
-   * resolver query parameters. The arguments are used to construct a resolver
-   * query object.
-   *
-   * @return \c this if a connection was successfully established, a null
-   * pointer otherwise.
-   */
-  template <typename T1, ..., typename TN>
-  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
-      T1 t1, ..., TN tn);
-#else
-  BOOST_PP_REPEAT_FROM_TO(
-      1, BOOST_PP_INC(ASIO_SOCKET_STREAMBUF_MAX_ARITY),
-      ASIO_PRIVATE_CONNECT_DEF, _ )
-#endif
-
-  /// Close the connection.
-  /**
-   * @return \c this if a connection was successfully established, a null
-   * pointer otherwise.
-   */
-  basic_socket_streambuf<Protocol, StreamSocketService>* close()
-  {
-    asio::error_code ec;
-    sync();
-    this->basic_socket<Protocol, StreamSocketService>::close(ec);
-    if (!ec)
-      init_buffers();
-    return !ec ? this : 0;
-  }
-
-protected:
-  int_type underflow()
-  {
-    if (gptr() == egptr())
-    {
-      asio::error_code ec;
-      std::size_t bytes_transferred = this->service.receive(
-          this->implementation,
-          asio::buffer(asio::buffer(get_buffer_) + putback_max),
-          0, ec);
-      if (ec)
-        return traits_type::eof();
-      setg(get_buffer_.begin(), get_buffer_.begin() + putback_max,
-          get_buffer_.begin() + putback_max + bytes_transferred);
-      return traits_type::to_int_type(*gptr());
-    }
-    else
-    {
-      return traits_type::eof();
-    }
-  }
-
-  int_type overflow(int_type c)
-  {
-    if (unbuffered_)
-    {
-      if (traits_type::eq_int_type(c, traits_type::eof()))
-      {
-        // Nothing to do.
-        return traits_type::not_eof(c);
-      }
-      else
-      {
-        // Send the single character immediately.
-        asio::error_code ec;
-        char_type ch = traits_type::to_char_type(c);
-        this->service.send(this->implementation,
-            asio::buffer(&ch, sizeof(char_type)), 0, ec);
-        if (ec)
-          return traits_type::eof();
-        return c;
-      }
-    }
-    else
-    {
-      // Send all data in the output buffer.
-      asio::const_buffer buffer =
-        asio::buffer(pbase(), pptr() - pbase());
-      while (asio::buffer_size(buffer) > 0)
-      {
-        asio::error_code ec;
-        std::size_t bytes_transferred = this->service.send(
-            this->implementation, asio::buffer(buffer),
-            0, ec);
-        if (ec)
-          return traits_type::eof();
-        buffer = buffer + bytes_transferred;
-      }
-      setp(put_buffer_.begin(), put_buffer_.end());
-
-      // If the new character is eof then our work here is done.
-      if (traits_type::eq_int_type(c, traits_type::eof()))
-        return traits_type::not_eof(c);
-
-      // Add the new character to the output buffer.
-      *pptr() = traits_type::to_char_type(c);
-      pbump(1);
-      return c;
-    }
-  }
-
-  int sync()
-  {
-    return overflow(traits_type::eof());
-  }
-
-  std::streambuf* setbuf(char_type* s, std::streamsize n)
-  {
-    if (pptr() == pbase() && s == 0 && n == 0)
-    {
-      unbuffered_ = true;
-      setp(0, 0);
-      return this;
-    }
-
-    return 0;
-  }
-
-private:
-  void init_buffers()
-  {
-    setg(get_buffer_.begin(),
-        get_buffer_.begin() + putback_max,
-        get_buffer_.begin() + putback_max);
-    if (unbuffered_)
-      setp(0, 0);
-    else
-      setp(put_buffer_.begin(), put_buffer_.end());
-  }
-
-  template <typename ResolverQuery>
-  void resolve_and_connect(const ResolverQuery& query,
-      asio::error_code& ec)
-  {
-    typedef typename Protocol::resolver resolver_type;
-    typedef typename resolver_type::iterator iterator_type;
-    resolver_type resolver(
-        boost::base_from_member<asio::io_service>::member);
-    iterator_type i = resolver.resolve(query, ec);
-    if (!ec)
-    {
-      iterator_type end;
-      ec = asio::error::host_not_found;
-      while (ec && i != end)
-      {
-        this->basic_socket<Protocol, StreamSocketService>::close();
-        this->basic_socket<Protocol, StreamSocketService>::connect(*i, ec);
-        ++i;
-      }
-    }
-  }
-
-  enum { putback_max = 8 };
-  enum { buffer_size = 512 };
-  boost::array<char, buffer_size> get_buffer_;
-  boost::array<char, buffer_size> put_buffer_;
-  bool unbuffered_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#undef ASIO_PRIVATE_CONNECT_DEF
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_SOCKET_STREAMBUF_HPP

ext/asio/asio/basic_stream_socket.hpp

@@ -1,715 +0,0 @@
-//
-// basic_stream_socket.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAM_SOCKET_HPP
-#define ASIO_BASIC_STREAM_SOCKET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/basic_socket.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-#include "asio/stream_socket_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Provides stream-oriented socket functionality.
-/**
- * The basic_stream_socket class template provides asynchronous and blocking
- * stream-oriented socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol> >
-class basic_stream_socket
-  : public basic_socket<Protocol, StreamSocketService>
-{
-public:
-  /// The native representation of a socket.
-  typedef typename StreamSocketService::native_type native_type;
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_stream_socket without opening it.
-  /**
-   * This constructor creates a stream socket without opening it. The socket
-   * needs to be opened and then connected or accepted before data can be sent
-   * or received on it.
-   *
-   * @param io_service The io_service object that the stream socket will use to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   */
-  explicit basic_stream_socket(asio::io_service& io_service)
-    : basic_socket<Protocol, StreamSocketService>(io_service)
-  {
-  }
-
-  /// Construct and open a basic_stream_socket.
-  /**
-   * This constructor creates and opens a stream socket. The socket needs to be
-   * connected or accepted before data can be sent or received on it.
-   *
-   * @param io_service The io_service object that the stream socket will use to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_socket(asio::io_service& io_service,
-      const protocol_type& protocol)
-    : basic_socket<Protocol, StreamSocketService>(io_service, protocol)
-  {
-  }
-
-  /// Construct a basic_stream_socket, opening it and binding it to the given
-  /// local endpoint.
-  /**
-   * This constructor creates a stream socket and automatically opens it bound
-   * to the specified endpoint on the local machine. The protocol used is the
-   * protocol associated with the given endpoint.
-   *
-   * @param io_service The io_service object that the stream socket will use to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the stream
-   * socket will be bound.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_socket(asio::io_service& io_service,
-      const endpoint_type& endpoint)
-    : basic_socket<Protocol, StreamSocketService>(io_service, endpoint)
-  {
-  }
-
-  /// Construct a basic_stream_socket on an existing native socket.
-  /**
-   * This constructor creates a stream socket object to hold an existing native
-   * socket.
-   *
-   * @param io_service The io_service object that the stream socket will use to
-   * dispatch handlers for any asynchronous operations performed on the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws asio::system_error Thrown on failure.
-   */
-  basic_stream_socket(asio::io_service& io_service,
-      const protocol_type& protocol, const native_type& native_socket)
-    : basic_socket<Protocol, StreamSocketService>(
-        io_service, protocol, native_socket)
-  {
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the stream socket. The function
-   * call will block until one or more bytes of the data has been sent
-   * successfully, or an until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.send(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the stream socket. The function
-   * call will block until one or more bytes of the data has been sent
-   * successfully, or an until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws asio::system_error Thrown on failure.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.send(asio::buffer(data, size), 0);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(
-        this->implementation, buffers, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the stream socket. The function
-   * call will block until one or more bytes of the data has been sent
-   * successfully, or an until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent. Returns 0 if an error occurred.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->service.send(this->implementation, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send data on the stream socket.
-   * The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers, WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, 0, handler);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send data on the stream socket.
-   * The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be sent on the socket. Although
-   * the buffers object may be copied as necessary, ownership of the underlying
-   * memory blocks is retained by the caller, which must guarantee that they
-   * remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(asio::buffer(data, size), 0, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on sending multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, flags, handler);
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the stream socket. The function
-   * call will block until one or more bytes of data has been received
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the stream socket. The function
-   * call will block until one or more bytes of data has been received
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(asio::buffer(data, size), 0);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(
-        this->implementation, buffers, flags, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the stream socket. The function
-   * call will block until one or more bytes of data has been received
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received. Returns 0 if an error occurred.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return this->service.receive(this->implementation, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the stream
-   * socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref async_read function if you need to ensure
-   * that the requested amount of data is received before the asynchronous
-   * operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers, ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the stream
-   * socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param flags Flags specifying how the receive call is to be made.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref async_read function if you need to ensure
-   * that the requested amount of data is received before the asynchronous
-   * operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(asio::buffer(data, size), 0, handler);
-   * @endcode
-   * See the @ref buffer documentation for information on receiving into
-   * multiple buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, flags, handler);
-  }
-
-  /// Write some data to the socket.
-  /**
-   * This function is used to write data to the stream socket. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the socket.
-   *
-   * @returns The number of bytes written.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.write_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Write some data to the socket.
-  /**
-   * This function is used to write data to the stream socket. The function call
-   * will block until one or more bytes of the data has been written
-   * successfully, or until an error occurs.
-   *
-   * @param buffers One or more data buffers to be written to the socket.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes written. Returns 0 if an error occurred.
-   *
-   * @note The write_some operation may not transmit all of the data to the
-   * peer. Consider using the @ref write function if you need to ensure that
-   * all data is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->service.send(this->implementation, buffers, 0, ec);
-  }
-
-  /// Start an asynchronous write.
-  /**
-   * This function is used to asynchronously write data to the stream socket.
-   * The function call always returns immediately.
-   *
-   * @param buffers One or more data buffers to be written to the socket.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the write operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes written.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The write operation may not transmit all of the data to the peer.
-   * Consider using the @ref async_write function if you need to ensure that all
-   * data is written before the asynchronous operation completes.
-   *
-   * @par Example
-   * To write a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_write_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on writing multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    this->service.async_send(this->implementation, buffers, 0, handler);
-  }
-
-  /// Read some data from the socket.
-  /**
-   * This function is used to read data from the stream socket. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @returns The number of bytes read.
-   *
-   * @throws asio::system_error Thrown on failure. An error code of
-   * asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.read_some(asio::buffer(data, size));
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    asio::error_code ec;
-    std::size_t s = this->service.receive(this->implementation, buffers, 0, ec);
-    asio::detail::throw_error(ec);
-    return s;
-  }
-
-  /// Read some data from the socket.
-  /**
-   * This function is used to read data from the stream socket. The function
-   * call will block until one or more bytes of data has been read successfully,
-   * or until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes read. Returns 0 if an error occurred.
-   *
-   * @note The read_some operation may not read all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that
-   * the requested amount of data is read before the blocking operation
-   * completes.
-   */
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return this->service.receive(this->implementation, buffers, 0, ec);
-  }
-
-  /// Start an asynchronous read.
-  /**
-   * This function is used to asynchronously read data from the stream socket.
-   * The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be read.
-   * Although the buffers object may be copied as necessary, ownership of the
-   * underlying memory blocks is retained by the caller, which must guarantee
-   * that they remain valid until the handler is called.
-   *
-   * @param handler The handler to be called when the read operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const asio::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes read.
-   * ); @endcode
-   * Regardless of whether the asynchronous operation completes immediately or
-   * not, the handler will not be invoked from within this function. Invocation
-   * of the handler will be performed in a manner equivalent to using
-   * asio::io_service::post().
-   *
-   * @note The read operation may not read all of the requested number of bytes.
-   * Consider using the @ref async_read function if you need to ensure that the
-   * requested amount of data is read before the asynchronous operation
-   * completes.
-   *
-   * @par Example
-   * To read into a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_read_some(asio::buffer(data, size), handler);
-   * @endcode
-   * See the @ref buffer documentation for information on reading into multiple
-   * buffers in one go, and how to use it with arrays, boost::array or
-   * std::vector.
-   */
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    this->service.async_receive(this->implementation, buffers, 0, handler);
-  }
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BASIC_STREAM_SOCKET_HPP

ext/asio/asio/basic_streambuf.hpp

@@ -1,366 +0,0 @@
-//
-// basic_streambuf.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAMBUF_HPP
-#define ASIO_BASIC_STREAMBUF_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#include <algorithm>
-#include <cstring>
-#include <stdexcept>
-#include <streambuf>
-#include <vector>
-#include <boost/limits.hpp>
-#include <boost/throw_exception.hpp>
-#include "asio/basic_streambuf_fwd.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/noncopyable.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Automatically resizable buffer class based on std::streambuf.
-/**
- * The @c basic_streambuf class is derived from @c std::streambuf to associate
- * the streambuf's input and output sequences with one or more character
- * arrays. These character arrays are internal to the @c basic_streambuf
- * object, but direct access to the array elements is provided to permit them
- * to be used efficiently with I/O operations. Characters written to the output
- * sequence of a @c basic_streambuf object are appended to the input sequence
- * of the same object.
- *
- * The @c basic_streambuf class's public interface is intended to permit the
- * following implementation strategies:
- *
- * @li A single contiguous character array, which is reallocated as necessary
- * to accommodate changes in the size of the character sequence. This is the
- * implementation approach currently used in Asio.
- *
- * @li A sequence of one or more character arrays, where each array is of the
- * same size. Additional character array objects are appended to the sequence
- * to accommodate changes in the size of the character sequence.
- *
- * @li A sequence of one or more character arrays of varying sizes. Additional
- * character array objects are appended to the sequence to accommodate changes
- * in the size of the character sequence.
- *
- * The constructor for basic_streambuf accepts a @c size_t argument specifying
- * the maximum of the sum of the sizes of the input sequence and output
- * sequence. During the lifetime of the @c basic_streambuf object, the following
- * invariant holds:
- * @code size() <= max_size()@endcode
- * Any member function that would, if successful, cause the invariant to be
- * violated shall throw an exception of class @c std::length_error.
- *
- * The constructor for @c basic_streambuf takes an Allocator argument. A copy
- * of this argument is used for any memory allocation performed, by the
- * constructor and by all member functions, during the lifetime of each @c
- * basic_streambuf object.
- *
- * @par Examples
- * Writing directly from an streambuf to a socket:
- * @code
- * asio::streambuf b;
- * std::ostream os(&b);
- * os << "Hello, World!\n";
- *
- * // try sending some data in input sequence
- * size_t n = sock.send(b.data());
- *
- * b.consume(n); // sent data is removed from input sequence
- * @endcode
- *
- * Reading from a socket directly into a streambuf:
- * @code
- * asio::streambuf b;
- *
- * // reserve 512 bytes in output sequence
- * asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
- *
- * size_t n = sock.receive(bufs);
- *
- * // received data is "committed" from output sequence to input sequence
- * b.commit(n);
- *
- * std::istream is(&b);
- * std::string s;
- * is >> s;
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-template <typename Allocator = std::allocator<char> >
-#else
-template <typename Allocator>
-#endif
-class basic_streambuf
-  : public std::streambuf,
-    private noncopyable
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type used to represent the input sequence as a list of buffers.
-  typedef implementation_defined const_buffers_type;
-
-  /// The type used to represent the output sequence as a list of buffers.
-  typedef implementation_defined mutable_buffers_type;
-#else
-  typedef asio::const_buffers_1 const_buffers_type;
-  typedef asio::mutable_buffers_1 mutable_buffers_type;
-#endif
-
-  /// Construct a basic_streambuf object.
-  /**
-   * Constructs a streambuf with the specified maximum size. The initial size
-   * of the streambuf's input sequence is 0.
-   */
-  explicit basic_streambuf(
-      std::size_t max_size = (std::numeric_limits<std::size_t>::max)(),
-      const Allocator& allocator = Allocator())
-    : max_size_(max_size),
-      buffer_(allocator)
-  {
-    std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
-    buffer_.resize((std::max<std::size_t>)(pend, 1));
-    setg(&buffer_[0], &buffer_[0], &buffer_[0]);
-    setp(&buffer_[0], &buffer_[0] + pend);
-  }
-
-  /// Get the size of the input sequence.
-  /**
-   * @returns The size of the input sequence. The value is equal to that
-   * calculated for @c s in the following code:
-   * @code
-   * size_t s = 0;
-   * const_buffers_type bufs = data();
-   * const_buffers_type::const_iterator i = bufs.begin();
-   * while (i != bufs.end())
-   * {
-   *   const_buffer buf(*i++);
-   *   s += buffer_size(buf);
-   * }
-   * @endcode
-   */
-  std::size_t size() const
-  {
-    return pptr() - gptr();
-  }
-
-  /// Get the maximum size of the basic_streambuf.
-  /**
-   * @returns The allowed maximum of the sum of the sizes of the input sequence
-   * and output sequence.
-   */
-  std::size_t max_size() const
-  {
-    return max_size_;
-  }
-
-  /// Get a list of buffers that represents the input sequence.
-  /**
-   * @returns An object of type @c const_buffers_type that satisfies
-   * ConstBufferSequence requirements, representing all character arrays in the
-   * input sequence.
-   *
-   * @note The returned object is invalidated by any @c basic_streambuf member
-   * function that modifies the input sequence or output sequence.
-   */
-  const_buffers_type data() const
-  {
-    return asio::buffer(asio::const_buffer(gptr(),
-          (pptr() - gptr()) * sizeof(char_type)));
-  }
-
-  /// Get a list of buffers that represents the output sequence, with the given
-  /// size.
-  /**
-   * Ensures that the output sequence can accommodate @c n characters,
-   * reallocating character array objects as necessary.
-   *
-   * @returns An object of type @c mutable_buffers_type that satisfies
-   * MutableBufferSequence requirements, representing character array objects
-   * at the start of the output sequence such that the sum of the buffer sizes
-   * is @c n.
-   *
-   * @throws std::length_error If <tt>size() + n > max_size()</tt>.
-   *
-   * @note The returned object is invalidated by any @c basic_streambuf member
-   * function that modifies the input sequence or output sequence.
-   */
-  mutable_buffers_type prepare(std::size_t n)
-  {
-    reserve(n);
-    return asio::buffer(asio::mutable_buffer(
-          pptr(), n * sizeof(char_type)));
-  }
-
-  /// Move characters from the output sequence to the input sequence.
-  /**
-   * Appends @c n characters from the start of the output sequence to the input
-   * sequence. The beginning of the output sequence is advanced by @c n
-   * characters.
-   *
-   * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
-   * no intervening operations that modify the input or output sequence.
-   *
-   * @throws std::length_error If @c n is greater than the size of the output
-   * sequence.
-   */
-  void commit(std::size_t n)
-  {
-    if (pptr() + n > epptr())
-      n = epptr() - pptr();
-    pbump(static_cast<int>(n));
-    setg(eback(), gptr(), pptr());
-  }
-
-  /// Remove characters from the input sequence.
-  /**
-   * Removes @c n characters from the beginning of the input sequence.
-   *
-   * @throws std::length_error If <tt>n > size()</tt>.
-   */
-  void consume(std::size_t n)
-  {
-    if (gptr() + n > pptr())
-      n = pptr() - gptr();
-    gbump(static_cast<int>(n));
-  }
-
-protected:
-  enum { buffer_delta = 128 };
-
-  /// Override std::streambuf behaviour.
-  /**
-   * Behaves according to the specification of @c std::streambuf::underflow().
-   */
-  int_type underflow()
-  {
-    if (gptr() < pptr())
-    {
-      setg(&buffer_[0], gptr(), pptr());
-      return traits_type::to_int_type(*gptr());
-    }
-    else
-    {
-      return traits_type::eof();
-    }
-  }
-
-  /// Override std::streambuf behaviour.
-  /**
-   * Behaves according to the specification of @c std::streambuf::overflow(),
-   * with the specialisation that @c std::length_error is thrown if appending
-   * the character to the input sequence would require the condition
-   * <tt>size() > max_size()</tt> to be true.
-   */
-  int_type overflow(int_type c)
-  {
-    if (!traits_type::eq_int_type(c, traits_type::eof()))
-    {
-      if (pptr() == epptr())
-      {
-        std::size_t buffer_size = pptr() - gptr();
-        if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
-        {
-          reserve(max_size_ - buffer_size);
-        }
-        else
-        {
-          reserve(buffer_delta);
-        }
-      }
-
-      *pptr() = traits_type::to_char_type(c);
-      pbump(1);
-      return c;
-    }
-
-    return traits_type::not_eof(c);
-  }
-
-  void reserve(std::size_t n)
-  {
-    // Get current stream positions as offsets.
-    std::size_t gnext = gptr() - &buffer_[0];
-    std::size_t pnext = pptr() - &buffer_[0];
-    std::size_t pend = epptr() - &buffer_[0];
-
-    // Check if there is already enough space in the put area.
-    if (n <= pend - pnext)
-    {
-      return;
-    }
-
-    // Shift existing contents of get area to start of buffer.
-    if (gnext > 0)
-    {
-      pnext -= gnext;
-      std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
-    }
-
-    // Ensure buffer is large enough to hold at least the specified size.
-    if (n > pend - pnext)
-    {
-      if (n <= max_size_ && pnext <= max_size_ - n)
-      {
-        pend = pnext + n;
-        buffer_.resize((std::max<std::size_t>)(pend, 1));
-      }
-      else
-      {
-        std::length_error ex("asio::streambuf too long");
-        boost::throw_exception(ex);
-      }
-    }
-
-    // Update stream positions.
-    setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
-    setp(&buffer_[0] + pnext, &buffer_[0] + pend);
-  }
-
-private:
-  std::size_t max_size_;
-  std::vector<char_type, Allocator> buffer_;
-
-  // Helper function to get the preferred size for reading data.
-  friend std::size_t read_size_helper(
-      basic_streambuf& sb, std::size_t max_size)
-  {
-    return std::min<std::size_t>(
-        std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
-        std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
-  }
-};
-
-// Helper function to get the preferred size for reading data. Used for any
-// user-provided specialisations of basic_streambuf.
-template <typename Allocator>
-inline std::size_t read_size_helper(
-    basic_streambuf<Allocator>& sb, std::size_t max_size)
-{
-  return std::min<std::size_t>(512,
-      std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_STREAMBUF_HPP

ext/asio/asio/basic_streambuf_fwd.hpp

@@ -1,33 +0,0 @@
-//
-// basic_streambuf_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BASIC_STREAMBUF_FWD_HPP
-#define ASIO_BASIC_STREAMBUF_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_NO_IOSTREAM)
-
-#include <memory>
-
-namespace asio {
-
-template <typename Allocator = std::allocator<char> >
-class basic_streambuf;
-
-} // namespace asio
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
-#endif // ASIO_BASIC_STREAMBUF_FWD_HPP

ext/asio/asio/buffered_read_stream.hpp

@@ -1,458 +0,0 @@
-//
-// buffered_read_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_READ_STREAM_HPP
-#define ASIO_BUFFERED_READ_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstring>
-#include <boost/type_traits/remove_reference.hpp>
-#include "asio/buffered_read_stream_fwd.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_resize_guard.hpp"
-#include "asio/detail/buffered_stream_storage.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Adds buffering to the read-related operations of a stream.
-/**
- * The buffered_read_stream class template can be used to add buffering to the
- * synchronous and asynchronous read operations of a stream.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, Sync_Read_Stream, SyncWriteStream.
- */
-template <typename Stream>
-class buffered_read_stream
-  : private noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef typename boost::remove_reference<Stream>::type next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The default buffer size.
-  static const std::size_t default_buffer_size = implementation_defined;
-#else
-  BOOST_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
-#endif
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_read_stream(Arg& a)
-    : next_layer_(a),
-      storage_(default_buffer_size)
-  {
-  }
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  buffered_read_stream(Arg& a, std::size_t buffer_size)
-    : next_layer_(a),
-      storage_(buffer_size)
-  {
-  }
-
-  /// Get a reference to the next layer.
-  next_layer_type& next_layer()
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the lowest layer.
-  lowest_layer_type& lowest_layer()
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  const lowest_layer_type& lowest_layer() const
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  asio::io_service& io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
-  /// Get the io_service associated with the object.
-  asio::io_service& get_io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
-  /// Close the stream.
-  void close()
-  {
-    next_layer_.close();
-  }
-
-  /// Close the stream.
-  asio::error_code close(asio::error_code& ec)
-  {
-    return next_layer_.close(ec);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written.
-  /// Throws an exception on failure.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    return next_layer_.write_some(buffers);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written,
-  /// or 0 if an error occurred.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return next_layer_.write_some(buffers, ec);
-  }
-
-  /// Start an asynchronous write. The data being written must be valid for the
-  /// lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    next_layer_.async_write_some(buffers, handler);
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation. Throws an exception on failure.
-  std::size_t fill()
-  {
-    detail::buffer_resize_guard<detail::buffered_stream_storage>
-      resize_guard(storage_);
-    std::size_t previous_size = storage_.size();
-    storage_.resize(storage_.capacity());
-    storage_.resize(previous_size + next_layer_.read_some(buffer(
-            storage_.data() + previous_size,
-            storage_.size() - previous_size)));
-    resize_guard.commit();
-    return storage_.size() - previous_size;
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation, or 0 if an error occurred.
-  std::size_t fill(asio::error_code& ec)
-  {
-    detail::buffer_resize_guard<detail::buffered_stream_storage>
-      resize_guard(storage_);
-    std::size_t previous_size = storage_.size();
-    storage_.resize(storage_.capacity());
-    storage_.resize(previous_size + next_layer_.read_some(buffer(
-            storage_.data() + previous_size,
-            storage_.size() - previous_size),
-          ec));
-    resize_guard.commit();
-    return storage_.size() - previous_size;
-  }
-
-  template <typename ReadHandler>
-  class fill_handler
-  {
-  public:
-    fill_handler(asio::io_service& io_service,
-        detail::buffered_stream_storage& storage,
-        std::size_t previous_size, ReadHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        previous_size_(previous_size),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_transferred)
-    {
-      storage_.resize(previous_size_ + bytes_transferred);
-      io_service_.dispatch(detail::bind_handler(
-            handler_, ec, bytes_transferred));
-    }
-
-  private:
-    asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    std::size_t previous_size_;
-    ReadHandler handler_;
-  };
-
-  /// Start an asynchronous fill.
-  template <typename ReadHandler>
-  void async_fill(ReadHandler handler)
-  {
-    std::size_t previous_size = storage_.size();
-    storage_.resize(storage_.capacity());
-    next_layer_.async_read_some(
-        buffer(
-          storage_.data() + previous_size,
-          storage_.size() - previous_size),
-        fill_handler<ReadHandler>(get_io_service(),
-          storage_, previous_size, handler));
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read. Throws
-  /// an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      asio::mutable_buffer buffer(*iter);
-      total_buffer_size += asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
-      return 0;
-
-    if (storage_.empty())
-      fill();
-
-    return copy(buffers);
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read or 0 if
-  /// an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      asio::mutable_buffer buffer(*iter);
-      total_buffer_size += asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
-      return 0;
-
-    if (storage_.empty() && !fill(ec))
-      return 0;
-
-    return copy(buffers);
-  }
-
-  template <typename MutableBufferSequence, typename ReadHandler>
-  class read_some_handler
-  {
-  public:
-    read_some_handler(asio::io_service& io_service,
-        detail::buffered_stream_storage& storage,
-        const MutableBufferSequence& buffers, ReadHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        buffers_(buffers),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const asio::error_code& ec, std::size_t)
-    {
-      if (ec || storage_.empty())
-      {
-        std::size_t length = 0;
-        io_service_.dispatch(detail::bind_handler(handler_, ec, length));
-      }
-      else
-      {
-        using namespace std; // For memcpy.
-
-        std::size_t bytes_avail = storage_.size();
-        std::size_t bytes_copied = 0;
-
-        typename MutableBufferSequence::const_iterator iter = buffers_.begin();
-        typename MutableBufferSequence::const_iterator end = buffers_.end();
-        for (; iter != end && bytes_avail > 0; ++iter)
-        {
-          std::size_t max_length = buffer_size(*iter);
-          std::size_t length = (max_length < bytes_avail)
-            ? max_length : bytes_avail;
-          memcpy(buffer_cast<void*>(*iter),
-              storage_.data() + bytes_copied, length);
-          bytes_copied += length;
-          bytes_avail -= length;
-        }
-
-        storage_.consume(bytes_copied);
-        io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
-      }
-    }
-
-  private:
-    asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    MutableBufferSequence buffers_;
-    ReadHandler handler_;
-  };
-
-  /// Start an asynchronous read. The buffer into which the data will be read
-  /// must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      asio::mutable_buffer buffer(*iter);
-      total_buffer_size += asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
-    {
-      get_io_service().post(detail::bind_handler(
-            handler, asio::error_code(), 0));
-    }
-    else if (storage_.empty())
-    {
-      async_fill(read_some_handler<MutableBufferSequence, ReadHandler>(
-            get_io_service(), storage_, buffers, handler));
-    }
-    else
-    {
-      std::size_t length = copy(buffers);
-      get_io_service().post(detail::bind_handler(
-            handler, asio::error_code(), length));
-    }
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read.
-  /// Throws an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    if (storage_.empty())
-      fill();
-    return peek_copy(buffers);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read,
-  /// or 0 if an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    if (storage_.empty() && !fill(ec))
-      return 0;
-    return peek_copy(buffers);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail()
-  {
-    return storage_.size();
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    ec = asio::error_code();
-    return storage_.size();
-  }
-
-private:
-  /// Copy data out of the internal buffer to the specified target buffer.
-  /// Returns the number of bytes copied.
-  template <typename MutableBufferSequence>
-  std::size_t copy(const MutableBufferSequence& buffers)
-  {
-    using namespace std; // For memcpy.
-
-    std::size_t bytes_avail = storage_.size();
-    std::size_t bytes_copied = 0;
-
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    for (; iter != end && bytes_avail > 0; ++iter)
-    {
-      std::size_t max_length = buffer_size(*iter);
-      std::size_t length = (max_length < bytes_avail)
-        ? max_length : bytes_avail;
-      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
-      bytes_copied += length;
-      bytes_avail -= length;
-    }
-
-    storage_.consume(bytes_copied);
-    return bytes_copied;
-  }
-
-  /// Copy data from the internal buffer to the specified target buffer, without
-  /// removing the data from the internal buffer. Returns the number of bytes
-  /// copied.
-  template <typename MutableBufferSequence>
-  std::size_t peek_copy(const MutableBufferSequence& buffers)
-  {
-    using namespace std; // For memcpy.
-
-    std::size_t bytes_avail = storage_.size();
-    std::size_t bytes_copied = 0;
-
-    typename MutableBufferSequence::const_iterator iter = buffers.begin();
-    typename MutableBufferSequence::const_iterator end = buffers.end();
-    for (; iter != end && bytes_avail > 0; ++iter)
-    {
-      std::size_t max_length = buffer_size(*iter);
-      std::size_t length = (max_length < bytes_avail)
-        ? max_length : bytes_avail;
-      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
-      bytes_copied += length;
-      bytes_avail -= length;
-    }
-
-    return bytes_copied;
-  }
-
-  /// The next layer.
-  Stream next_layer_;
-
-  // The data in the buffer.
-  detail::buffered_stream_storage storage_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFERED_READ_STREAM_HPP

ext/asio/asio/buffered_read_stream_fwd.hpp

@@ -1,25 +0,0 @@
-//
-// buffered_read_stream_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_READ_STREAM_FWD_HPP
-#define ASIO_BUFFERED_READ_STREAM_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace asio {
-
-template <typename Stream>
-class buffered_read_stream;
-
-} // namespace asio
-
-#endif // ASIO_BUFFERED_READ_STREAM_FWD_HPP

ext/asio/asio/buffered_stream.hpp

@@ -1,253 +0,0 @@
-//
-// buffered_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_STREAM_HPP
-#define ASIO_BUFFERED_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/buffered_read_stream.hpp"
-#include "asio/buffered_write_stream.hpp"
-#include "asio/buffered_stream_fwd.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Adds buffering to the read- and write-related operations of a stream.
-/**
- * The buffered_stream class template can be used to add buffering to the
- * synchronous and asynchronous read and write operations of a stream.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Stream>
-class buffered_stream
-  : private noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef typename boost::remove_reference<Stream>::type next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_stream(Arg& a)
-    : inner_stream_impl_(a),
-      stream_impl_(inner_stream_impl_)
-  {
-  }
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
-      std::size_t write_buffer_size)
-    : inner_stream_impl_(a, write_buffer_size),
-      stream_impl_(inner_stream_impl_, read_buffer_size)
-  {
-  }
-
-  /// Get a reference to the next layer.
-  next_layer_type& next_layer()
-  {
-    return stream_impl_.next_layer().next_layer();
-  }
-
-  /// Get a reference to the lowest layer.
-  lowest_layer_type& lowest_layer()
-  {
-    return stream_impl_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  const lowest_layer_type& lowest_layer() const
-  {
-    return stream_impl_.lowest_layer();
-  }
-
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  asio::io_service& io_service()
-  {
-    return stream_impl_.get_io_service();
-  }
-
-  /// Get the io_service associated with the object.
-  asio::io_service& get_io_service()
-  {
-    return stream_impl_.get_io_service();
-  }
-
-  /// Close the stream.
-  void close()
-  {
-    stream_impl_.close();
-  }
-
-  /// Close the stream.
-  asio::error_code close(asio::error_code& ec)
-  {
-    return stream_impl_.close(ec);
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation. Throws an
-  /// exception on failure.
-  std::size_t flush()
-  {
-    return stream_impl_.next_layer().flush();
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation, or 0 if an
-  /// error occurred.
-  std::size_t flush(asio::error_code& ec)
-  {
-    return stream_impl_.next_layer().flush(ec);
-  }
-
-  /// Start an asynchronous flush.
-  template <typename WriteHandler>
-  void async_flush(WriteHandler handler)
-  {
-    return stream_impl_.next_layer().async_flush(handler);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written.
-  /// Throws an exception on failure.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    return stream_impl_.write_some(buffers);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written,
-  /// or 0 if an error occurred.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return stream_impl_.write_some(buffers, ec);
-  }
-
-  /// Start an asynchronous write. The data being written must be valid for the
-  /// lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    stream_impl_.async_write_some(buffers, handler);
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation. Throws an exception on failure.
-  std::size_t fill()
-  {
-    return stream_impl_.fill();
-  }
-
-  /// Fill the buffer with some data. Returns the number of bytes placed in the
-  /// buffer as a result of the operation, or 0 if an error occurred.
-  std::size_t fill(asio::error_code& ec)
-  {
-    return stream_impl_.fill(ec);
-  }
-
-  /// Start an asynchronous fill.
-  template <typename ReadHandler>
-  void async_fill(ReadHandler handler)
-  {
-    stream_impl_.async_fill(handler);
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read. Throws
-  /// an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    return stream_impl_.read_some(buffers);
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read or 0 if
-  /// an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return stream_impl_.read_some(buffers, ec);
-  }
-
-  /// Start an asynchronous read. The buffer into which the data will be read
-  /// must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    stream_impl_.async_read_some(buffers, handler);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read.
-  /// Throws an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    return stream_impl_.peek(buffers);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read,
-  /// or 0 if an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return stream_impl_.peek(buffers, ec);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail()
-  {
-    return stream_impl_.in_avail();
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    return stream_impl_.in_avail(ec);
-  }
-
-private:
-  // The buffered write stream.
-  typedef buffered_write_stream<Stream> write_stream_type;
-  write_stream_type inner_stream_impl_;
-
-  // The buffered read stream.
-  typedef buffered_read_stream<write_stream_type&> read_stream_type;
-  read_stream_type stream_impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFERED_STREAM_HPP

ext/asio/asio/buffered_stream_fwd.hpp

@@ -1,25 +0,0 @@
-//
-// buffered_stream_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_STREAM_FWD_HPP
-#define ASIO_BUFFERED_STREAM_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace asio {
-
-template <typename Stream>
-class buffered_stream;
-
-} // namespace asio
-
-#endif // ASIO_BUFFERED_STREAM_FWD_HPP

ext/asio/asio/buffered_write_stream.hpp

@@ -1,412 +0,0 @@
-//
-// buffered_write_stream.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_WRITE_STREAM_HPP
-#define ASIO_BUFFERED_WRITE_STREAM_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <cstring>
-#include <boost/type_traits/remove_reference.hpp>
-#include "asio/buffered_write_stream_fwd.hpp"
-#include "asio/buffer.hpp"
-#include "asio/completion_condition.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffered_stream_storage.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/write.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Adds buffering to the write-related operations of a stream.
-/**
- * The buffered_write_stream class template can be used to add buffering to the
- * synchronous and asynchronous write operations of a stream.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
- */
-template <typename Stream>
-class buffered_write_stream
-  : private noncopyable
-{
-public:
-  /// The type of the next layer.
-  typedef typename boost::remove_reference<Stream>::type next_layer_type;
-
-  /// The type of the lowest layer.
-  typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The default buffer size.
-  static const std::size_t default_buffer_size = implementation_defined;
-#else
-  BOOST_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
-#endif
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  explicit buffered_write_stream(Arg& a)
-    : next_layer_(a),
-      storage_(default_buffer_size)
-  {
-  }
-
-  /// Construct, passing the specified argument to initialise the next layer.
-  template <typename Arg>
-  buffered_write_stream(Arg& a, std::size_t buffer_size)
-    : next_layer_(a),
-      storage_(buffer_size)
-  {
-  }
-
-  /// Get a reference to the next layer.
-  next_layer_type& next_layer()
-  {
-    return next_layer_;
-  }
-
-  /// Get a reference to the lowest layer.
-  lowest_layer_type& lowest_layer()
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// Get a const reference to the lowest layer.
-  const lowest_layer_type& lowest_layer() const
-  {
-    return next_layer_.lowest_layer();
-  }
-
-  /// (Deprecated: use get_io_service().) Get the io_service associated with
-  /// the object.
-  asio::io_service& io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
-  /// Get the io_service associated with the object.
-  asio::io_service& get_io_service()
-  {
-    return next_layer_.get_io_service();
-  }
-
-  /// Close the stream.
-  void close()
-  {
-    next_layer_.close();
-  }
-
-  /// Close the stream.
-  asio::error_code close(asio::error_code& ec)
-  {
-    return next_layer_.close(ec);
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation. Throws an
-  /// exception on failure.
-  std::size_t flush()
-  {
-    std::size_t bytes_written = write(next_layer_,
-        buffer(storage_.data(), storage_.size()));
-    storage_.consume(bytes_written);
-    return bytes_written;
-  }
-
-  /// Flush all data from the buffer to the next layer. Returns the number of
-  /// bytes written to the next layer on the last write operation, or 0 if an
-  /// error occurred.
-  std::size_t flush(asio::error_code& ec)
-  {
-    std::size_t bytes_written = write(next_layer_,
-        buffer(storage_.data(), storage_.size()),
-        transfer_all(), ec);
-    storage_.consume(bytes_written);
-    return bytes_written;
-  }
-
-  template <typename WriteHandler>
-  class flush_handler
-  {
-  public:
-    flush_handler(asio::io_service& io_service,
-        detail::buffered_stream_storage& storage, WriteHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const asio::error_code& ec,
-        std::size_t bytes_written)
-    {
-      storage_.consume(bytes_written);
-      io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_written));
-    }
-
-  private:
-    asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    WriteHandler handler_;
-  };
-
-  /// Start an asynchronous flush.
-  template <typename WriteHandler>
-  void async_flush(WriteHandler handler)
-  {
-    async_write(next_layer_, buffer(storage_.data(), storage_.size()),
-        flush_handler<WriteHandler>(get_io_service(), storage_, handler));
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written.
-  /// Throws an exception on failure.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      asio::const_buffer buffer(*iter);
-      total_buffer_size += asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
-      return 0;
-
-    if (storage_.size() == storage_.capacity())
-      flush();
-
-    return copy(buffers);
-  }
-
-  /// Write the given data to the stream. Returns the number of bytes written,
-  /// or 0 if an error occurred and the error handler did not throw.
-  template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    ec = asio::error_code();
-
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      asio::const_buffer buffer(*iter);
-      total_buffer_size += asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
-      return 0;
-
-    if (storage_.size() == storage_.capacity() && !flush(ec))
-      return 0;
-
-    return copy(buffers);
-  }
-
-  template <typename ConstBufferSequence, typename WriteHandler>
-  class write_some_handler
-  {
-  public:
-    write_some_handler(asio::io_service& io_service,
-        detail::buffered_stream_storage& storage,
-        const ConstBufferSequence& buffers, WriteHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        buffers_(buffers),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const asio::error_code& ec, std::size_t)
-    {
-      if (ec)
-      {
-        std::size_t length = 0;
-        io_service_.dispatch(detail::bind_handler(handler_, ec, length));
-      }
-      else
-      {
-        using namespace std; // For memcpy.
-
-        std::size_t orig_size = storage_.size();
-        std::size_t space_avail = storage_.capacity() - orig_size;
-        std::size_t bytes_copied = 0;
-
-        typename ConstBufferSequence::const_iterator iter = buffers_.begin();
-        typename ConstBufferSequence::const_iterator end = buffers_.end();
-        for (; iter != end && space_avail > 0; ++iter)
-        {
-          std::size_t bytes_avail = buffer_size(*iter);
-          std::size_t length = (bytes_avail < space_avail)
-            ? bytes_avail : space_avail;
-          storage_.resize(orig_size + bytes_copied + length);
-          memcpy(storage_.data() + orig_size + bytes_copied,
-              buffer_cast<const void*>(*iter), length);
-          bytes_copied += length;
-          space_avail -= length;
-        }
-
-        io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
-      }
-    }
-
-  private:
-    asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    ConstBufferSequence buffers_;
-    WriteHandler handler_;
-  };
-
-  /// Start an asynchronous write. The data being written must be valid for the
-  /// lifetime of the asynchronous operation.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    size_t total_buffer_size = 0;
-    for (; iter != end; ++iter)
-    {
-      asio::const_buffer buffer(*iter);
-      total_buffer_size += asio::buffer_size(buffer);
-    }
-
-    if (total_buffer_size == 0)
-    {
-      get_io_service().post(detail::bind_handler(
-            handler, asio::error_code(), 0));
-    }
-    else if (storage_.size() == storage_.capacity())
-    {
-      async_flush(write_some_handler<ConstBufferSequence, WriteHandler>(
-            get_io_service(), storage_, buffers, handler));
-    }
-    else
-    {
-      std::size_t bytes_copied = copy(buffers);
-      get_io_service().post(detail::bind_handler(
-            handler, asio::error_code(), bytes_copied));
-    }
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read. Throws
-  /// an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    return next_layer_.read_some(buffers);
-  }
-
-  /// Read some data from the stream. Returns the number of bytes read or 0 if
-  /// an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return next_layer_.read_some(buffers, ec);
-  }
-
-  /// Start an asynchronous read. The buffer into which the data will be read
-  /// must be valid for the lifetime of the asynchronous operation.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    next_layer_.async_read_some(buffers, handler);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read.
-  /// Throws an exception on failure.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    return next_layer_.peek(buffers);
-  }
-
-  /// Peek at the incoming data on the stream. Returns the number of bytes read,
-  /// or 0 if an error occurred.
-  template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers,
-      asio::error_code& ec)
-  {
-    return next_layer_.peek(buffers, ec);
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail()
-  {
-    return next_layer_.in_avail();
-  }
-
-  /// Determine the amount of data that may be read without blocking.
-  std::size_t in_avail(asio::error_code& ec)
-  {
-    return next_layer_.in_avail(ec);
-  }
-
-private:
-  /// Copy data into the internal buffer from the specified source buffer.
-  /// Returns the number of bytes copied.
-  template <typename ConstBufferSequence>
-  std::size_t copy(const ConstBufferSequence& buffers)
-  {
-    using namespace std; // For memcpy.
-
-    std::size_t orig_size = storage_.size();
-    std::size_t space_avail = storage_.capacity() - orig_size;
-    std::size_t bytes_copied = 0;
-
-    typename ConstBufferSequence::const_iterator iter = buffers.begin();
-    typename ConstBufferSequence::const_iterator end = buffers.end();
-    for (; iter != end && space_avail > 0; ++iter)
-    {
-      std::size_t bytes_avail = buffer_size(*iter);
-      std::size_t length = (bytes_avail < space_avail)
-        ? bytes_avail : space_avail;
-      storage_.resize(orig_size + bytes_copied + length);
-      memcpy(storage_.data() + orig_size + bytes_copied,
-          buffer_cast<const void*>(*iter), length);
-      bytes_copied += length;
-      space_avail -= length;
-    }
-
-    return bytes_copied;
-  }
-
-  /// The next layer.
-  Stream next_layer_;
-
-  // The data in the buffer.
-  detail::buffered_stream_storage storage_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFERED_WRITE_STREAM_HPP

ext/asio/asio/buffered_write_stream_fwd.hpp

@@ -1,25 +0,0 @@
-//
-// buffered_write_stream_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
-#define ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace asio {
-
-template <typename Stream>
-class buffered_write_stream;
-
-} // namespace asio
-
-#endif // ASIO_BUFFERED_WRITE_STREAM_FWD_HPP

ext/asio/asio/buffers_iterator.hpp

@@ -1,453 +0,0 @@
-//
-// buffers_iterator.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_BUFFERS_ITERATOR_HPP
-#define ASIO_BUFFERS_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/iterator.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include "asio/buffer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail
-{
-  template <bool IsMutable>
-  struct buffers_iterator_types_helper;
-
-  template <>
-  struct buffers_iterator_types_helper<false>
-  {
-    typedef const_buffer buffer_type;
-    template <typename ByteType>
-    struct byte_type
-    {
-      typedef typename boost::add_const<ByteType>::type type;
-    };
-  };
-
-  template <>
-  struct buffers_iterator_types_helper<true>
-  {
-    typedef mutable_buffer buffer_type;
-    template <typename ByteType>
-    struct byte_type
-    {
-      typedef ByteType type;
-    };
-  };
-
-  template <typename BufferSequence, typename ByteType>
-  struct buffers_iterator_types
-  {
-    enum
-    {
-      is_mutable = boost::is_convertible<
-        typename BufferSequence::value_type, mutable_buffer>::value
-    };
-    typedef buffers_iterator_types_helper<is_mutable> helper;
-    typedef typename helper::buffer_type buffer_type;
-    typedef typename helper::template byte_type<ByteType>::type byte_type;
-  };
-}
-
-/// A random access iterator over the bytes in a buffer sequence.
-template <typename BufferSequence, typename ByteType = char>
-class buffers_iterator
-  : public boost::iterator<
-      std::random_access_iterator_tag,
-      typename detail::buffers_iterator_types<
-        BufferSequence, ByteType>::byte_type>
-{
-private:
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::buffer_type buffer_type;
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::byte_type byte_type;
-
-public:
-  /// Default constructor. Creates an iterator in an undefined state.
-  buffers_iterator()
-    : current_buffer_(),
-      current_buffer_position_(0),
-      begin_(),
-      current_(),
-      end_(),
-      position_(0)
-  {
-  }
-
-  /// Construct an iterator representing the beginning of the buffers' data.
-  static buffers_iterator begin(const BufferSequence& buffers)
-#if BOOST_WORKAROUND(__GNUC__, == 4) && BOOST_WORKAROUND(__GNUC_MINOR__, == 3)
-    __attribute__ ((noinline))
-#endif
-  {
-    buffers_iterator new_iter;
-    new_iter.begin_ = buffers.begin();
-    new_iter.current_ = buffers.begin();
-    new_iter.end_ = buffers.end();
-    while (new_iter.current_ != new_iter.end_)
-    {
-      new_iter.current_buffer_ = *new_iter.current_;
-      if (asio::buffer_size(new_iter.current_buffer_) > 0)
-        break;
-      ++new_iter.current_;
-    }
-    return new_iter;
-  }
-
-  /// Construct an iterator representing the end of the buffers' data.
-  static buffers_iterator end(const BufferSequence& buffers)
-#if BOOST_WORKAROUND(__GNUC__, == 4) && BOOST_WORKAROUND(__GNUC_MINOR__, == 3)
-    __attribute__ ((noinline))
-#endif
-  {
-    buffers_iterator new_iter;
-    new_iter.begin_ = buffers.begin();
-    new_iter.current_ = buffers.begin();
-    new_iter.end_ = buffers.end();
-    while (new_iter.current_ != new_iter.end_)
-    {
-      buffer_type buffer = *new_iter.current_;
-      new_iter.position_ += asio::buffer_size(buffer);
-      ++new_iter.current_;
-    }
-    return new_iter;
-  }
-
-  /// Dereference an iterator.
-  byte_type& operator*() const
-  {
-    return dereference();
-  }
-
-  /// Dereference an iterator.
-  byte_type* operator->() const
-  {
-    return &dereference();
-  }
-
-  /// Access an individual element.
-  byte_type& operator[](std::ptrdiff_t difference) const
-  {
-    buffers_iterator tmp(*this);
-    tmp.advance(difference);
-    return *tmp;
-  }
-
-  /// Increment operator (prefix).
-  buffers_iterator& operator++()
-  {
-    increment();
-    return *this;
-  }
-
-  /// Increment operator (postfix).
-  buffers_iterator operator++(int)
-  {
-    buffers_iterator tmp(*this);
-    ++*this;
-    return tmp;
-  }
-
-  /// Decrement operator (prefix).
-  buffers_iterator& operator--()
-  {
-    decrement();
-    return *this;
-  }
-
-  /// Decrement operator (postfix).
-  buffers_iterator operator--(int)
-  {
-    buffers_iterator tmp(*this);
-    --*this;
-    return tmp;
-  }
-
-  /// Addition operator.
-  buffers_iterator& operator+=(std::ptrdiff_t difference)
-  {
-    advance(difference);
-    return *this;
-  }
-
-  /// Subtraction operator.
-  buffers_iterator& operator-=(std::ptrdiff_t difference)
-  {
-    advance(-difference);
-    return *this;
-  }
-
-  /// Addition operator.
-  friend buffers_iterator operator+(const buffers_iterator& iter,
-      std::ptrdiff_t difference)
-  {
-    buffers_iterator tmp(iter);
-    tmp.advance(difference);
-    return tmp;
-  }
-
-  /// Addition operator.
-  friend buffers_iterator operator+(std::ptrdiff_t difference,
-      const buffers_iterator& iter)
-  {
-    buffers_iterator tmp(iter);
-    tmp.advance(difference);
-    return tmp;
-  }
-
-  /// Subtraction operator.
-  friend buffers_iterator operator-(const buffers_iterator& iter,
-      std::ptrdiff_t difference)
-  {
-    buffers_iterator tmp(iter);
-    tmp.advance(-difference);
-    return tmp;
-  }
-
-  /// Subtraction operator.
-  friend std::ptrdiff_t operator-(const buffers_iterator& a,
-      const buffers_iterator& b)
-  {
-    return b.distance_to(a);
-  }
-
-  /// Test two iterators for equality.
-  friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return a.equal(b);
-  }
-
-  /// Test two iterators for inequality.
-  friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return !a.equal(b);
-  }
-
-  /// Compare two iterators.
-  friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return a.distance_to(b) > 0;
-  }
-
-  /// Compare two iterators.
-  friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return !(b < a);
-  }
-
-  /// Compare two iterators.
-  friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return b < a;
-  }
-
-  /// Compare two iterators.
-  friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
-  {
-    return !(a < b);
-  }
-
-private:
-  // Dereference the iterator.
-  byte_type& dereference() const
-  {
-    return buffer_cast<byte_type*>(current_buffer_)[current_buffer_position_];
-  }
-
-  // Compare two iterators for equality.
-  bool equal(const buffers_iterator& other) const
-  {
-    return position_ == other.position_;
-  }
-
-  // Increment the iterator.
-  void increment()
-  {
-    BOOST_ASSERT(current_ != end_ && "iterator out of bounds");
-    ++position_;
-
-    // Check if the increment can be satisfied by the current buffer.
-    ++current_buffer_position_;
-    if (current_buffer_position_ != asio::buffer_size(current_buffer_))
-      return;
-
-    // Find the next non-empty buffer.
-    ++current_;
-    current_buffer_position_ = 0;
-    while (current_ != end_)
-    {
-      current_buffer_ = *current_;
-      if (asio::buffer_size(current_buffer_) > 0)
-        return;
-      ++current_;
-    }
-  }
-
-  // Decrement the iterator.
-  void decrement()
-  {
-    BOOST_ASSERT(position_ > 0 && "iterator out of bounds");
-    --position_;
-
-    // Check if the decrement can be satisfied by the current buffer.
-    if (current_buffer_position_ != 0)
-    {
-      --current_buffer_position_;
-      return;
-    }
-
-    // Find the previous non-empty buffer.
-    typename BufferSequence::const_iterator iter = current_;
-    while (iter != begin_)
-    {
-      --iter;
-      buffer_type buffer = *iter;
-      std::size_t buffer_size = asio::buffer_size(buffer);
-      if (buffer_size > 0)
-      {
-        current_ = iter;
-        current_buffer_ = buffer;
-        current_buffer_position_ = buffer_size - 1;
-        return;
-      }
-    }
-  }
-
-  // Advance the iterator by the specified distance.
-  void advance(std::ptrdiff_t n)
-  {
-    if (n > 0)
-    {
-      BOOST_ASSERT(current_ != end_ && "iterator out of bounds");
-      for (;;)
-      {
-        std::ptrdiff_t current_buffer_balance
-          = asio::buffer_size(current_buffer_)
-          - current_buffer_position_;
-
-        // Check if the advance can be satisfied by the current buffer.
-        if (current_buffer_balance > n)
-        {
-          position_ += n;
-          current_buffer_position_ += n;
-          return;
-        }
-
-        // Update position.
-        n -= current_buffer_balance;
-        position_ += current_buffer_balance;
-
-        // Move to next buffer. If it is empty then it will be skipped on the
-        // next iteration of this loop.
-        if (++current_ == end_)
-        {
-          BOOST_ASSERT(n == 0 && "iterator out of bounds");
-          current_buffer_ = buffer_type();
-          current_buffer_position_ = 0;
-          return;
-        }
-        current_buffer_ = *current_;
-        current_buffer_position_ = 0;
-      }
-    }
-    else if (n < 0)
-    {
-      std::size_t abs_n = -n;
-      BOOST_ASSERT(position_ >= abs_n && "iterator out of bounds");
-      for (;;)
-      {
-        // Check if the advance can be satisfied by the current buffer.
-        if (current_buffer_position_ >= abs_n)
-        {
-          position_ -= abs_n;
-          current_buffer_position_ -= abs_n;
-          return;
-        }
-
-        // Update position.
-        abs_n -= current_buffer_position_;
-        position_ -= current_buffer_position_;
-
-        // Check if we've reached the beginning of the buffers.
-        if (current_ == begin_)
-        {
-          BOOST_ASSERT(abs_n == 0 && "iterator out of bounds");
-          current_buffer_position_ = 0;
-          return;
-        }
-
-        // Find the previous non-empty buffer.
-        typename BufferSequence::const_iterator iter = current_;
-        while (iter != begin_)
-        {
-          --iter;
-          buffer_type buffer = *iter;
-          std::size_t buffer_size = asio::buffer_size(buffer);
-          if (buffer_size > 0)
-          {
-            current_ = iter;
-            current_buffer_ = buffer;
-            current_buffer_position_ = buffer_size;
-            break;
-          }
-        }
-      }
-    }
-  }
-
-  // Determine the distance between two iterators.
-  std::ptrdiff_t distance_to(const buffers_iterator& other) const
-  {
-    return other.position_ - position_;
-  }
-
-  buffer_type current_buffer_;
-  std::size_t current_buffer_position_;
-  typename BufferSequence::const_iterator begin_;
-  typename BufferSequence::const_iterator current_;
-  typename BufferSequence::const_iterator end_;
-  std::size_t position_;
-};
-
-/// Construct an iterator representing the beginning of the buffers' data.
-template <typename BufferSequence>
-inline buffers_iterator<BufferSequence> buffers_begin(
-    const BufferSequence& buffers)
-{
-  return buffers_iterator<BufferSequence>::begin(buffers);
-}
-
-/// Construct an iterator representing the end of the buffers' data.
-template <typename BufferSequence>
-inline buffers_iterator<BufferSequence> buffers_end(
-    const BufferSequence& buffers)
-{
-  return buffers_iterator<BufferSequence>::end(buffers);
-}
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_BUFFERS_ITERATOR_HPP

ext/asio/asio/completion_condition.hpp

@@ -1,162 +0,0 @@
-//
-// completion_condition.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_COMPLETION_CONDITION_HPP
-#define ASIO_COMPLETION_CONDITION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-namespace detail {
-
-// The default maximum number of bytes to transfer in a single operation.
-enum { default_max_transfer_size = 65536 };
-
-// Adapt result of old-style completion conditions (which had a bool result
-// where true indicated that the operation was complete).
-inline std::size_t adapt_completion_condition_result(bool result)
-{
-  return result ? 0 : default_max_transfer_size;
-}
-
-// Adapt result of current completion conditions (which have a size_t result
-// where 0 means the operation is complete, and otherwise the result is the
-// maximum number of bytes to transfer on the next underlying operation).
-inline std::size_t adapt_completion_condition_result(std::size_t result)
-{
-  return result;
-}
-
-class transfer_all_t
-{
-public:
-  typedef std::size_t result_type;
-
-  template <typename Error>
-  std::size_t operator()(const Error& err, std::size_t)
-  {
-    return !!err ? 0 : default_max_transfer_size;
-  }
-};
-
-class transfer_at_least_t
-{
-public:
-  typedef std::size_t result_type;
-
-  explicit transfer_at_least_t(std::size_t minimum)
-    : minimum_(minimum)
-  {
-  }
-
-  template <typename Error>
-  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
-  {
-    return (!!err || bytes_transferred >= minimum_)
-      ? 0 : default_max_transfer_size;
-  }
-
-private:
-  std::size_t minimum_;
-};
-
-} // namespace detail
-
-/**
- * @defgroup completion_condition Completion Condition Function Objects
- *
- * Function objects used for determining when a read or write operation should
- * complete.
- */
-/*@{*/
-
-/// Return a completion condition function object that indicates that a read or
-/// write operation should continue until all of the data has been transferred,
-/// or until an error occurs.
-/**
- * This function is used to create an object, of unspecified type, that meets
- * CompletionCondition requirements.
- *
- * @par Example
- * Reading until a buffer is full:
- * @code
- * boost::array<char, 128> buf;
- * asio::error_code ec;
- * std::size_t n = asio::read(
- *     sock, asio::buffer(buf),
- *     asio::transfer_all(), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   // n == 128
- * }
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-unspecified transfer_all();
-#else
-inline detail::transfer_all_t transfer_all()
-{
-  return detail::transfer_all_t();
-}
-#endif
-
-/// Return a completion condition function object that indicates that a read or
-/// write operation should continue until a minimum number of bytes has been
-/// transferred, or until an error occurs.
-/**
- * This function is used to create an object, of unspecified type, that meets
- * CompletionCondition requirements.
- *
- * @par Example
- * Reading until a buffer is full or contains at least 64 bytes:
- * @code
- * boost::array<char, 128> buf;
- * asio::error_code ec;
- * std::size_t n = asio::read(
- *     sock, asio::buffer(buf),
- *     asio::transfer_at_least(64), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   // n >= 64 && n <= 128
- * }
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-unspecified transfer_at_least(std::size_t minimum);
-#else
-inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
-{
-  return detail::transfer_at_least_t(minimum);
-}
-#endif
-
-/*@}*/
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_COMPLETION_CONDITION_HPP

ext/asio/asio/datagram_socket_service.hpp

@@ -1,311 +0,0 @@
-//
-// datagram_socket_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DATAGRAM_SOCKET_SERVICE_HPP
-#define ASIO_DATAGRAM_SOCKET_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-# include "asio/detail/win_iocp_socket_service.hpp"
-#else
-# include "asio/detail/reactive_socket_service.hpp"
-#endif
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Default service implementation for a datagram socket.
-template <typename Protocol>
-class datagram_socket_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
-#else
-  : public asio::detail::service_base<datagram_socket_service<Protocol> >
-#endif
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static asio::io_service::id id;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-private:
-  // The type of the platform-specific implementation.
-#if defined(ASIO_HAS_IOCP)
-  typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
-#else
-  typedef detail::reactive_socket_service<Protocol> service_impl_type;
-#endif
-
-public:
-  /// The type of a datagram socket.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined implementation_type;
-#else
-  typedef typename service_impl_type::implementation_type implementation_type;
-#endif
-
-  /// The native socket type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef typename service_impl_type::native_type native_type;
-#endif
-
-  /// Construct a new datagram socket service for the specified io_service.
-  explicit datagram_socket_service(asio::io_service& io_service)
-    : asio::detail::service_base<
-        datagram_socket_service<Protocol> >(io_service),
-      service_impl_(io_service)
-  {
-  }
-
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  /// Construct a new datagram socket implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-  /// Destroy a datagram socket implementation.
-  void destroy(implementation_type& impl)
-  {
-    service_impl_.destroy(impl);
-  }
-
-  // Open a new datagram socket implementation.
-  asio::error_code open(implementation_type& impl,
-      const protocol_type& protocol, asio::error_code& ec)
-  {
-    if (protocol.type() == SOCK_DGRAM)
-      service_impl_.open(impl, protocol, ec);
-    else
-      ec = asio::error::invalid_argument;
-    return ec;
-  }
-
-  /// Assign an existing native socket to a datagram socket.
-  asio::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_type& native_socket,
-      asio::error_code& ec)
-  {
-    return service_impl_.assign(impl, protocol, native_socket, ec);
-  }
-
-  /// Determine whether the socket is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return service_impl_.is_open(impl);
-  }
-
-  /// Close a datagram socket implementation.
-  asio::error_code close(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// Get the native socket implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native(impl);
-  }
-
-  /// Cancel all asynchronous operations associated with the socket.
-  asio::error_code cancel(implementation_type& impl,
-      asio::error_code& ec)
-  {
-    return service_impl_.cancel(impl, ec);
-  }
-
-  /// Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return service_impl_.at_mark(impl, ec);
-  }
-
-  /// Determine the number of bytes available for reading.
-  std::size_t available(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return service_impl_.available(impl, ec);
-  }
-
-  // Bind the datagram socket to the specified local endpoint.
-  asio::error_code bind(implementation_type& impl,
-      const endpoint_type& endpoint, asio::error_code& ec)
-  {
-    return service_impl_.bind(impl, endpoint, ec);
-  }
-
-  /// Connect the datagram socket to the specified endpoint.
-  asio::error_code connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, asio::error_code& ec)
-  {
-    return service_impl_.connect(impl, peer_endpoint, ec);
-  }
-
-  /// Start an asynchronous connect.
-  template <typename ConnectHandler>
-  void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, ConnectHandler handler)
-  {
-    service_impl_.async_connect(impl, peer_endpoint, handler);
-  }
-
-  /// Set a socket option.
-  template <typename SettableSocketOption>
-  asio::error_code set_option(implementation_type& impl,
-      const SettableSocketOption& option, asio::error_code& ec)
-  {
-    return service_impl_.set_option(impl, option, ec);
-  }
-
-  /// Get a socket option.
-  template <typename GettableSocketOption>
-  asio::error_code get_option(const implementation_type& impl,
-      GettableSocketOption& option, asio::error_code& ec) const
-  {
-    return service_impl_.get_option(impl, option, ec);
-  }
-
-  /// Perform an IO control command on the socket.
-  template <typename IoControlCommand>
-  asio::error_code io_control(implementation_type& impl,
-      IoControlCommand& command, asio::error_code& ec)
-  {
-    return service_impl_.io_control(impl, command, ec);
-  }
-
-  /// Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return service_impl_.local_endpoint(impl, ec);
-  }
-
-  /// Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type& impl,
-      asio::error_code& ec) const
-  {
-    return service_impl_.remote_endpoint(impl, ec);
-  }
-
-  /// Disable sends or receives on the socket.
-  asio::error_code shutdown(implementation_type& impl,
-      socket_base::shutdown_type what, asio::error_code& ec)
-  {
-    return service_impl_.shutdown(impl, what, ec);
-  }
-
-  /// Send the given data to the peer.
-  template <typename ConstBufferSequence>
-  std::size_t send(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return service_impl_.send(impl, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(implementation_type& impl, const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, WriteHandler handler)
-  {
-    service_impl_.async_send(impl, buffers, flags, handler);
-  }
-
-  /// Send a datagram to the specified endpoint.
-  template <typename ConstBufferSequence>
-  std::size_t send_to(implementation_type& impl,
-      const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return service_impl_.send_to(impl, buffers, destination, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(implementation_type& impl,
-      const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags, WriteHandler handler)
-  {
-    service_impl_.async_send_to(impl, buffers, destination, flags, handler);
-  }
-
-  /// Receive some data from the peer.
-  template <typename MutableBufferSequence>
-  std::size_t receive(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return service_impl_.receive(impl, buffers, flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, ReadHandler handler)
-  {
-    service_impl_.async_receive(impl, buffers, flags, handler);
-  }
-
-  /// Receive a datagram with the endpoint of the sender.
-  template <typename MutableBufferSequence>
-  std::size_t receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, asio::error_code& ec)
-  {
-    return service_impl_.receive_from(impl, buffers, sender_endpoint, flags,
-        ec);
-  }
-
-  /// Start an asynchronous receive that will get the endpoint of the sender.
-  template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(implementation_type& impl,
-      const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, ReadHandler handler)
-  {
-    service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
-        handler);
-  }
-
-private:
-  // The platform-specific implementation.
-  service_impl_type service_impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DATAGRAM_SOCKET_SERVICE_HPP

ext/asio/asio/deadline_timer.hpp

@@ -1,33 +0,0 @@
-//
-// deadline_timer.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DEADLINE_TIMER_HPP
-#define ASIO_DEADLINE_TIMER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/socket_types.hpp" // Must come before posix_time.
-#include "asio/basic_deadline_timer.hpp"
-
-#include "asio/detail/push_options.hpp"
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-#include "asio/detail/pop_options.hpp"
-
-namespace asio {
-
-/// Typedef for the typical usage of timer. Uses a UTC clock.
-typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
-
-} // namespace asio
-
-#endif // ASIO_DEADLINE_TIMER_HPP

ext/asio/asio/deadline_timer_service.hpp

@@ -1,146 +0,0 @@
-//
-// deadline_timer_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DEADLINE_TIMER_SERVICE_HPP
-#define ASIO_DEADLINE_TIMER_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/detail/deadline_timer_service.hpp"
-#include "asio/io_service.hpp"
-#include "asio/time_traits.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-
-/// Default service implementation for a timer.
-template <typename TimeType,
-    typename TimeTraits = asio::time_traits<TimeType> >
-class deadline_timer_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public asio::io_service::service
-#else
-  : public asio::detail::service_base<
-      deadline_timer_service<TimeType, TimeTraits> >
-#endif
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static asio::io_service::id id;
-#endif
-
-  /// The time traits type.
-  typedef TimeTraits traits_type;
-
-  /// The time type.
-  typedef typename traits_type::time_type time_type;
-
-  /// The duration type.
-  typedef typename traits_type::duration_type duration_type;
-
-private:
-  // The type of the platform-specific implementation.
-  typedef detail::deadline_timer_service<traits_type> service_impl_type;
-
-public:
-  /// The implementation type of the deadline timer.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined implementation_type;
-#else
-  typedef typename service_impl_type::implementation_type implementation_type;
-#endif
-
-  /// Construct a new timer service for the specified io_service.
-  explicit deadline_timer_service(asio::io_service& io_service)
-    : asio::detail::service_base<
-        deadline_timer_service<TimeType, TimeTraits> >(io_service),
-      service_impl_(io_service)
-  {
-  }
-
-  /// Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  /// Construct a new timer implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-  /// Destroy a timer implementation.
-  void destroy(implementation_type& impl)
-  {
-    service_impl_.destroy(impl);
-  }
-
-  /// Cancel any asynchronous wait operations associated with the timer.
-  std::size_t cancel(implementation_type& impl, asio::error_code& ec)
-  {
-    return service_impl_.cancel(impl, ec);
-  }
-
-  /// Get the expiry time for the timer as an absolute time.
-  time_type expires_at(const implementation_type& impl) const
-  {
-    return service_impl_.expires_at(impl);
-  }
-
-  /// Set the expiry time for the timer as an absolute time.
-  std::size_t expires_at(implementation_type& impl,
-      const time_type& expiry_time, asio::error_code& ec)
-  {
-    return service_impl_.expires_at(impl, expiry_time, ec);
-  }
-
-  /// Get the expiry time for the timer relative to now.
-  duration_type expires_from_now(const implementation_type& impl) const
-  {
-    return service_impl_.expires_from_now(impl);
-  }
-
-  /// Set the expiry time for the timer relative to now.
-  std::size_t expires_from_now(implementation_type& impl,
-      const duration_type& expiry_time, asio::error_code& ec)
-  {
-    return service_impl_.expires_from_now(impl, expiry_time, ec);
-  }
-
-  // Perform a blocking wait on the timer.
-  void wait(implementation_type& impl, asio::error_code& ec)
-  {
-    service_impl_.wait(impl, ec);
-  }
-
-  // Start an asynchronous wait on the timer.
-  template <typename WaitHandler>
-  void async_wait(implementation_type& impl, WaitHandler handler)
-  {
-    service_impl_.async_wait(impl, handler);
-  }
-
-private:
-  // The platform-specific implementation.
-  service_impl_type service_impl_;
-};
-
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DEADLINE_TIMER_SERVICE_HPP

ext/asio/asio/detail/array_fwd.hpp

@@ -1,25 +0,0 @@
-//
-// detail/array_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_ARRAY_FWD_HPP
-#define ASIO_DETAIL_ARRAY_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace boost {
-
-template<class T, std::size_t N>
-class array;
-
-} // namespace boost
-
-#endif // ASIO_DETAIL_ARRAY_FWD_HPP

ext/asio/asio/detail/base_from_completion_cond.hpp

@@ -1,68 +0,0 @@
-//
-// detail/base_from_completion_cond.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
-#define ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/completion_condition.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename CompletionCondition>
-class base_from_completion_cond
-{
-protected:
-  explicit base_from_completion_cond(CompletionCondition completion_condition)
-    : completion_condition_(completion_condition)
-  {
-  }
-
-  std::size_t check_for_completion(
-      const asio::error_code& ec,
-      std::size_t total_transferred)
-  {
-    return detail::adapt_completion_condition_result(
-        completion_condition_(ec, total_transferred));
-  }
-
-private:
-  CompletionCondition completion_condition_;
-};
-
-template <>
-class base_from_completion_cond<transfer_all_t>
-{
-protected:
-  explicit base_from_completion_cond(transfer_all_t)
-  {
-  }
-
-  static std::size_t check_for_completion(
-      const asio::error_code& ec,
-      std::size_t total_transferred)
-  {
-    return transfer_all_t()(ec, total_transferred);
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP

ext/asio/asio/detail/bind_handler.hpp

@@ -1,360 +0,0 @@
-//
-// detail/bind_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BIND_HANDLER_HPP
-#define ASIO_DETAIL_BIND_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler, typename Arg1>
-class binder1
-{
-public:
-  binder1(const Handler& handler, const Arg1& arg1)
-    : handler_(handler),
-      arg1_(arg1)
-  {
-  }
-
-  void operator()()
-  {
-    handler_(static_cast<const Arg1&>(arg1_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-};
-
-template <typename Handler, typename Arg1>
-inline void* asio_handler_allocate(std::size_t size,
-    binder1<Handler, Arg1>* this_handler)
-{
-  return asio_handler_alloc_helpers::allocate(
-      size, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
-    binder1<Handler, Arg1>* this_handler)
-{
-  asio_handler_alloc_helpers::deallocate(
-      pointer, size, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1>
-inline void asio_handler_invoke(const Function& function,
-    binder1<Handler, Arg1>* this_handler)
-{
-  asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1>
-inline binder1<Handler, Arg1> bind_handler(const Handler& handler,
-    const Arg1& arg1)
-{
-  return binder1<Handler, Arg1>(handler, arg1);
-}
-
-template <typename Handler, typename Arg1, typename Arg2>
-class binder2
-{
-public:
-  binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
-    : handler_(handler),
-      arg1_(arg1),
-      arg2_(arg2)
-  {
-  }
-
-  void operator()()
-  {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2>
-inline void* asio_handler_allocate(std::size_t size,
-    binder2<Handler, Arg1, Arg2>* this_handler)
-{
-  return asio_handler_alloc_helpers::allocate(
-      size, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
-    binder2<Handler, Arg1, Arg2>* this_handler)
-{
-  asio_handler_alloc_helpers::deallocate(
-      pointer, size, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2>
-inline void asio_handler_invoke(const Function& function,
-    binder2<Handler, Arg1, Arg2>* this_handler)
-{
-  asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2>
-inline binder2<Handler, Arg1, Arg2> bind_handler(const Handler& handler,
-    const Arg1& arg1, const Arg2& arg2)
-{
-  return binder2<Handler, Arg1, Arg2>(handler, arg1, arg2);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-class binder3
-{
-public:
-  binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3)
-    : handler_(handler),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3)
-  {
-  }
-
-  void operator()()
-  {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_, arg3_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-  Arg3 arg3_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline void* asio_handler_allocate(std::size_t size,
-    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
-{
-  return asio_handler_alloc_helpers::allocate(
-      size, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
-    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
-{
-  asio_handler_alloc_helpers::deallocate(
-      pointer, size, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3>
-inline void asio_handler_invoke(const Function& function,
-    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
-{
-  asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline binder3<Handler, Arg1, Arg2, Arg3> bind_handler(const Handler& handler,
-    const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
-{
-  return binder3<Handler, Arg1, Arg2, Arg3>(handler, arg1, arg2, arg3);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
-class binder4
-{
-public:
-  binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4)
-    : handler_(handler),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4)
-  {
-  }
-
-  void operator()()
-  {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_, arg3_, arg4_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-  Arg3 arg3_;
-  Arg4 arg4_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
-inline void* asio_handler_allocate(std::size_t size,
-    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
-{
-  return asio_handler_alloc_helpers::allocate(
-      size, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
-    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
-{
-  asio_handler_alloc_helpers::deallocate(
-      pointer, size, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4>
-inline void asio_handler_invoke(const Function& function,
-    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
-{
-  asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4>
-inline binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
-    const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-    const Arg3& arg3, const Arg4& arg4)
-{
-  return binder4<Handler, Arg1, Arg2, Arg3, Arg4>(handler, arg1, arg2, arg3,
-      arg4);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
-class binder5
-{
-public:
-  binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-    : handler_(handler),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4),
-      arg5_(arg5)
-  {
-  }
-
-  void operator()()
-  {
-    handler_(static_cast<const Arg1&>(arg1_),
-        static_cast<const Arg2&>(arg2_),
-        static_cast<const Arg3&>(arg3_),
-        static_cast<const Arg4&>(arg4_),
-        static_cast<const Arg5&>(arg5_));
-  }
-
-  void operator()() const
-  {
-    handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
-  }
-
-//private:
-  Handler handler_;
-  Arg1 arg1_;
-  Arg2 arg2_;
-  Arg3 arg3_;
-  Arg4 arg4_;
-  Arg5 arg5_;
-};
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
-inline void* asio_handler_allocate(std::size_t size,
-    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
-{
-  return asio_handler_alloc_helpers::allocate(
-      size, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
-inline void asio_handler_deallocate(void* pointer, std::size_t size,
-    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
-{
-  asio_handler_alloc_helpers::deallocate(
-      pointer, size, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
-inline void asio_handler_invoke(const Function& function,
-    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
-{
-  asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-}
-
-template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
-    typename Arg4, typename Arg5>
-inline binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
-    const Handler& handler, const Arg1& arg1, const Arg2& arg2,
-    const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-{
-  return binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>(handler, arg1, arg2,
-      arg3, arg4, arg5);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BIND_HANDLER_HPP

ext/asio/asio/detail/buffer_resize_guard.hpp

@@ -1,68 +0,0 @@
-//
-// detail/buffer_resize_guard.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
-#define ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <boost/limits.hpp>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper class to manage buffer resizing in an exception safe way.
-template <typename Buffer>
-class buffer_resize_guard
-{
-public:
-  // Constructor.
-  buffer_resize_guard(Buffer& buffer)
-    : buffer_(buffer),
-      old_size_(buffer.size())
-  {
-  }
-
-  // Destructor rolls back the buffer resize unless commit was called.
-  ~buffer_resize_guard()
-  {
-    if (old_size_
-        != std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION())
-    {
-      buffer_.resize(old_size_);
-    }
-  }
-
-  // Commit the resize transaction.
-  void commit()
-  {
-    old_size_
-      = std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION();
-  }
-
-private:
-  // The buffer being managed.
-  Buffer& buffer_;
-
-  // The size of the buffer at the time the guard was constructed.
-  size_t old_size_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP

ext/asio/asio/detail/buffer_sequence_adapter.hpp

@@ -1,254 +0,0 @@
-//
-// detail/buffer_sequence_adapter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
-#define ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/buffer.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class buffer_sequence_adapter_base
-{
-protected:
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  typedef WSABUF native_buffer_type;
-
-  static void init_native_buffer(WSABUF& buf,
-      const asio::mutable_buffer& buffer)
-  {
-    buf.buf = asio::buffer_cast<char*>(buffer);
-    buf.len = static_cast<ULONG>(asio::buffer_size(buffer));
-  }
-
-  static void init_native_buffer(WSABUF& buf,
-      const asio::const_buffer& buffer)
-  {
-    buf.buf = const_cast<char*>(asio::buffer_cast<const char*>(buffer));
-    buf.len = static_cast<ULONG>(asio::buffer_size(buffer));
-  }
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  typedef iovec native_buffer_type;
-
-  static void init_iov_base(void*& base, void* addr)
-  {
-    base = addr;
-  }
-
-  template <typename T>
-  static void init_iov_base(T& base, void* addr)
-  {
-    base = static_cast<T>(addr);
-  }
-
-  static void init_native_buffer(iovec& iov,
-      const asio::mutable_buffer& buffer)
-  {
-    init_iov_base(iov.iov_base, asio::buffer_cast<void*>(buffer));
-    iov.iov_len = asio::buffer_size(buffer);
-  }
-
-  static void init_native_buffer(iovec& iov,
-      const asio::const_buffer& buffer)
-  {
-    init_iov_base(iov.iov_base, const_cast<void*>(
-          asio::buffer_cast<const void*>(buffer)));
-    iov.iov_len = asio::buffer_size(buffer);
-  }
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-};
-
-// Helper class to translate buffers into the native buffer representation.
-template <typename Buffer, typename Buffers>
-class buffer_sequence_adapter
-  : buffer_sequence_adapter_base
-{
-public:
-  explicit buffer_sequence_adapter(const Buffers& buffers)
-    : count_(0), total_buffer_size_(0)
-  {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
-    for (; iter != end && count_ < max_buffers; ++iter, ++count_)
-    {
-      Buffer buffer(*iter);
-      init_native_buffer(buffers_[count_], buffer);
-      total_buffer_size_ += asio::buffer_size(buffer);
-    }
-  }
-
-  native_buffer_type* buffers()
-  {
-    return buffers_;
-  }
-
-  std::size_t count() const
-  {
-    return count_;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const Buffers& buffers)
-  {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
-    std::size_t i = 0;
-    for (; iter != end && i < max_buffers; ++iter, ++i)
-      if (asio::buffer_size(Buffer(*iter)) > 0)
-        return false;
-    return true;
-  }
-
-  static void validate(const Buffers& buffers)
-  {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
-    for (; iter != end; ++iter)
-    {
-      Buffer buffer(*iter);
-      asio::buffer_cast<const void*>(buffer);
-    }
-  }
-
-  static Buffer first(const Buffers& buffers)
-  {
-    typename Buffers::const_iterator iter = buffers.begin();
-    typename Buffers::const_iterator end = buffers.end();
-    for (; iter != end; ++iter)
-    {
-      Buffer buffer(*iter);
-      if (asio::buffer_size(buffer) != 0)
-        return buffer;
-    }
-    return Buffer();
-  }
-
-private:
-  // The maximum number of buffers to support in a single operation.
-  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
-
-  native_buffer_type buffers_[max_buffers];
-  std::size_t count_;
-  std::size_t total_buffer_size_;
-};
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
-  : buffer_sequence_adapter_base
-{
-public:
-  explicit buffer_sequence_adapter(
-      const asio::mutable_buffers_1& buffers)
-  {
-    init_native_buffer(buffer_, Buffer(buffers));
-    total_buffer_size_ = asio::buffer_size(buffers);
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const asio::mutable_buffers_1& buffers)
-  {
-    return asio::buffer_size(buffers) == 0;
-  }
-
-  static void validate(const asio::mutable_buffers_1& buffers)
-  {
-    asio::buffer_cast<const void*>(buffers);
-  }
-
-  static Buffer first(const asio::mutable_buffers_1& buffers)
-  {
-    return Buffer(buffers);
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-};
-
-template <typename Buffer>
-class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
-  : buffer_sequence_adapter_base
-{
-public:
-  explicit buffer_sequence_adapter(
-      const asio::const_buffers_1& buffers)
-  {
-    init_native_buffer(buffer_, Buffer(buffers));
-    total_buffer_size_ = asio::buffer_size(buffers);
-  }
-
-  native_buffer_type* buffers()
-  {
-    return &buffer_;
-  }
-
-  std::size_t count() const
-  {
-    return 1;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const asio::const_buffers_1& buffers)
-  {
-    return asio::buffer_size(buffers) == 0;
-  }
-
-  static void validate(const asio::const_buffers_1& buffers)
-  {
-    asio::buffer_cast<const void*>(buffers);
-  }
-
-  static Buffer first(const asio::const_buffers_1& buffers)
-  {
-    return Buffer(buffers);
-  }
-
-private:
-  native_buffer_type buffer_;
-  std::size_t total_buffer_size_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP

ext/asio/asio/detail/buffered_stream_storage.hpp

@@ -1,125 +0,0 @@
-//
-// detail/buffered_stream_storage.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
-#define ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cassert>
-#include <cstddef>
-#include <cstring>
-#include <vector>
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class buffered_stream_storage
-{
-public:
-  // The type of the bytes stored in the buffer.
-  typedef unsigned char byte_type;
-
-  // The type used for offsets into the buffer.
-  typedef std::size_t size_type;
-
-  // Constructor.
-  explicit buffered_stream_storage(std::size_t capacity)
-    : begin_offset_(0),
-      end_offset_(0),
-      buffer_(capacity)
-  {
-  }
-
-  /// Clear the buffer.
-  void clear()
-  {
-    begin_offset_ = 0;
-    end_offset_ = 0;
-  }
-
-  // Return a pointer to the beginning of the unread data.
-  byte_type* data()
-  {
-    return &buffer_[0] + begin_offset_;
-  }
-
-  // Return a pointer to the beginning of the unread data.
-  const byte_type* data() const
-  {
-    return &buffer_[0] + begin_offset_;
-  }
-
-  // Is there no unread data in the buffer.
-  bool empty() const
-  {
-    return begin_offset_ == end_offset_;
-  }
-
-  // Return the amount of unread data the is in the buffer.
-  size_type size() const
-  {
-    return end_offset_ - begin_offset_;
-  }
-
-  // Resize the buffer to the specified length.
-  void resize(size_type length)
-  {
-    assert(length <= capacity());
-    if (begin_offset_ + length <= capacity())
-    {
-      end_offset_ = begin_offset_ + length;
-    }
-    else
-    {
-      using namespace std; // For memmove.
-      memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
-      end_offset_ = length;
-      begin_offset_ = 0;
-    }
-  }
-
-  // Return the maximum size for data in the buffer.
-  size_type capacity() const
-  {
-    return buffer_.size();
-  }
-
-  // Consume multiple bytes from the beginning of the buffer.
-  void consume(size_type count)
-  {
-    assert(begin_offset_ + count <= end_offset_);
-    begin_offset_ += count;
-    if (empty())
-      clear();
-  }
-
-private:
-  // The offset to the beginning of the unread data.
-  size_type begin_offset_;
-
-  // The offset to the end of the unread data.
-  size_type end_offset_;
-  
-  // The data in the buffer.
-  std::vector<byte_type> buffer_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP

ext/asio/asio/detail/call_stack.hpp

@@ -1,91 +0,0 @@
-//
-// detail/call_stack.hpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CALL_STACK_HPP
-#define ASIO_DETAIL_CALL_STACK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/tss_ptr.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// Helper class to determine whether or not the current thread is inside an
-// invocation of io_service::run() for a specified io_service object.
-template <typename Owner>
-class call_stack
-{
-public:
-  // Context class automatically pushes an owner on to the stack.
-  class context
-    : private noncopyable
-  {
-  public:
-    // Push the owner on to the stack.
-    explicit context(Owner* d)
-      : owner_(d),
-        next_(call_stack<Owner>::top_)
-    {
-      call_stack<Owner>::top_ = this;
-    }
-
-    // Pop the owner from the stack.
-    ~context()
-    {
-      call_stack<Owner>::top_ = next_;
-    }
-
-  private:
-    friend class call_stack<Owner>;
-
-    // The owner associated with the context.
-    Owner* owner_;
-
-    // The next element in the stack.
-    context* next_;
-  };
-
-  friend class context;
-
-  // Determine whether the specified owner is on the stack.
-  static bool contains(Owner* d)
-  {
-    context* elem = top_;
-    while (elem)
-    {
-      if (elem->owner_ == d)
-        return true;
-      elem = elem->next_;
-    }
-    return false;
-  }
-
-private:
-  // The top of the stack of calls for the current thread.
-  static tss_ptr<context> top_;
-};
-
-template <typename Owner>
-tss_ptr<typename call_stack<Owner>::context>
-call_stack<Owner>::top_;
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CALL_STACK_HPP

ext/asio/asio/detail/completion_handler.hpp

@@ -1,75 +0,0 @@
-//
-// detail/completion_handler.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_COMPLETION_HANDLER_HPP
-#define ASIO_DETAIL_COMPLETION_HANDLER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-#include "asio/detail/operation.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler>
-class completion_handler : public operation
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(completion_handler);
-
-  completion_handler(Handler h)
-    : operation(&completion_handler::do_complete),
-      handler_(h)
-  {
-  }
-
-  static void do_complete(io_service_impl* owner, operation* base,
-      asio::error_code /*ec*/, std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    completion_handler* h(static_cast<completion_handler*>(base));
-    ptr p = { boost::addressof(h->handler_), h, h };
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    Handler handler(h->handler_);
-    p.h = boost::addressof(handler);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      asio::detail::fenced_block b;
-      asio_handler_invoke_helpers::invoke(handler, handler);
-    }
-  }
-
-private:
-  Handler handler_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_COMPLETION_HANDLER_HPP

ext/asio/asio/detail/config.hpp

@@ -1,205 +0,0 @@
-//
-// detail/config.hpp
-// ~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONFIG_HPP
-#define ASIO_DETAIL_CONFIG_HPP
-
-#include <boost/config.hpp>
-
-// Default to a header-only implementation. The user must specifically request
-// separate compilation by defining either ASIO_SEPARATE_COMPILATION or
-// ASIO_DYN_LINK (as a DLL/shared library implies separate compilation).
-#if !defined(ASIO_HEADER_ONLY)
-# if !defined(ASIO_SEPARATE_COMPILATION)
-#  if !defined(ASIO_DYN_LINK)
-#   define ASIO_HEADER_ONLY
-#  endif // !defined(ASIO_DYN_LINK)
-# endif // !defined(ASIO_SEPARATE_COMPILATION)
-#endif // !defined(ASIO_HEADER_ONLY)
-
-#if defined(ASIO_HEADER_ONLY)
-# define ASIO_DECL inline
-#else // defined(ASIO_HEADER_ONLY)
-# if defined(BOOST_HAS_DECLSPEC)
-// We need to import/export our code only if the user has specifically asked
-// for it by defining ASIO_DYN_LINK.
-#  if defined(ASIO_DYN_LINK)
-// Export if this is our own source, otherwise import.
-#   if defined(ASIO_SOURCE)
-#    define ASIO_DECL __declspec(dllexport)
-#   else // defined(ASIO_SOURCE)
-#    define ASIO_DECL __declspec(dllimport)
-#   endif // defined(ASIO_SOURCE)
-#  endif // defined(ASIO_DYN_LINK)
-# endif // defined(BOOST_HAS_DECLSPEC)
-#endif // defined(ASIO_HEADER_ONLY)
-
-// If ASIO_DECL isn't defined yet define it now.
-#if !defined(ASIO_DECL)
-# define ASIO_DECL
-#endif // !defined(ASIO_DECL)
-
-// Windows: target OS version.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
-#  if defined(_MSC_VER) || defined(__BORLANDC__)
-#   pragma message( \
-  "Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For example:\n"\
-  "- add -D_WIN32_WINNT=0x0501 to the compiler command line; or\n"\
-  "- add _WIN32_WINNT=0x0501 to your project's Preprocessor Definitions.\n"\
-  "Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP target).")
-#  else // defined(_MSC_VER) || defined(__BORLANDC__)
-#   warning Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately.
-#   warning For example, add -D_WIN32_WINNT=0x0501 to the compiler command line.
-#   warning Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP target).
-#  endif // defined(_MSC_VER) || defined(__BORLANDC__)
-#  define _WIN32_WINNT 0x0501
-# endif // !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
-# if defined(_MSC_VER)
-#  if defined(_WIN32) && !defined(WIN32)
-#   if !defined(_WINSOCK2API_)
-#    define WIN32 // Needed for correct types in winsock2.h
-#   else // !defined(_WINSOCK2API_)
-#    error Please define the macro WIN32 in your compiler options
-#   endif // !defined(_WINSOCK2API_)
-#  endif // defined(_WIN32) && !defined(WIN32)
-# endif // defined(_MSC_VER)
-# if defined(__BORLANDC__)
-#  if defined(__WIN32__) && !defined(WIN32)
-#   if !defined(_WINSOCK2API_)
-#    define WIN32 // Needed for correct types in winsock2.h
-#   else // !defined(_WINSOCK2API_)
-#    error Please define the macro WIN32 in your compiler options
-#   endif // !defined(_WINSOCK2API_)
-#  endif // defined(__WIN32__) && !defined(WIN32)
-# endif // defined(__BORLANDC__)
-# if defined(__CYGWIN__)
-#  if !defined(__USE_W32_SOCKETS)
-#   error You must add -D__USE_W32_SOCKETS to your compiler options.
-#  endif // !defined(__USE_W32_SOCKETS)
-# endif // defined(__CYGWIN__)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-// Windows: minimise header inclusion.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if !defined(ASIO_NO_WIN32_LEAN_AND_MEAN)
-#  if !defined(WIN32_LEAN_AND_MEAN)
-#   define WIN32_LEAN_AND_MEAN
-#  endif // !defined(WIN32_LEAN_AND_MEAN)
-# endif // !defined(ASIO_NO_WIN32_LEAN_AND_MEAN)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-// Windows: suppress definition of "min" and "max" macros.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if !defined(ASIO_NO_NOMINMAX)
-#  if !defined(NOMINMAX)
-#   define NOMINMAX 1
-#  endif // !defined(NOMINMAX)
-# endif // !defined(ASIO_NO_NOMINMAX)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-// Windows: IO Completion Ports.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-#  if !defined(UNDER_CE)
-#   if !defined(ASIO_DISABLE_IOCP)
-#    define ASIO_HAS_IOCP 1
-#   endif // !defined(ASIO_DISABLE_IOCP)
-#  endif // !defined(UNDER_CE)
-# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-// Linux: epoll, eventfd and timerfd.
-#if defined(__linux__)
-# include <linux/version.h>
-# if !defined(ASIO_DISABLE_EPOLL)
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
-#   define ASIO_HAS_EPOLL 1
-#  endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
-# endif // !defined(ASIO_DISABLE_EVENTFD)
-# if !defined(ASIO_DISABLE_EVENTFD)
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-#   define ASIO_HAS_EVENTFD 1
-#  endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-# endif // !defined(ASIO_DISABLE_EVENTFD)
-# if defined(ASIO_HAS_EPOLL)
-#  if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
-#   define ASIO_HAS_TIMERFD 1
-#  endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
-# endif // defined(ASIO_HAS_EPOLL)
-#endif // defined(__linux__)
-
-// Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue.
-#if (defined(__MACH__) && defined(__APPLE__)) \
-  || defined(__FreeBSD__) \
-  || defined(__NetBSD__) \
-  || defined(__OpenBSD__)
-# if !defined(ASIO_DISABLE_KQUEUE)
-#  define ASIO_HAS_KQUEUE 1
-# endif // !defined(ASIO_DISABLE_KQUEUE)
-#endif // (defined(__MACH__) && defined(__APPLE__))
-       //   || defined(__FreeBSD__)
-       //   || defined(__NetBSD__)
-       //   || defined(__OpenBSD__)
-
-// Solaris: /dev/poll.
-#if defined(__sun)
-# if !defined(ASIO_DISABLE_DEV_POLL)
-#  define ASIO_HAS_DEV_POLL 1
-# endif // !defined(ASIO_DISABLE_DEV_POLL)
-#endif // defined(__sun)
-
-// Serial ports.
-#if defined(ASIO_HAS_IOCP) \
-   || !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-# if !defined(__SYMBIAN32__)
-#  if !defined(ASIO_DISABLE_SERIAL_PORT)
-#   define ASIO_HAS_SERIAL_PORT 1
-#  endif // !defined(ASIO_DISABLE_SERIAL_PORT)
-# endif // !defined(__SYMBIAN32__)
-#endif // defined(ASIO_HAS_IOCP)
-       //   || !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-// Windows: stream handles.
-#if !defined(ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
-# if defined(ASIO_HAS_IOCP)
-#  define ASIO_HAS_WINDOWS_STREAM_HANDLE 1
-# endif // defined(ASIO_HAS_IOCP)
-#endif // !defined(ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
-
-// Windows: random access handles.
-#if !defined(ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
-# if defined(ASIO_HAS_IOCP)
-#  define ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1
-# endif // defined(ASIO_HAS_IOCP)
-#endif // !defined(ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
-
-// Windows: OVERLAPPED wrapper.
-#if !defined(ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
-# if defined(ASIO_HAS_IOCP)
-#  define ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1
-# endif // defined(ASIO_HAS_IOCP)
-#endif // !defined(ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
-
-// POSIX: stream-oriented file descriptors.
-#if !defined(ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
-# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#  define ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
-# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#endif // !defined(ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
-
-// UNIX domain sockets.
-#if !defined(ASIO_DISABLE_LOCAL_SOCKETS)
-# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#  define ASIO_HAS_LOCAL_SOCKETS 1
-# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#endif // !defined(ASIO_DISABLE_LOCAL_SOCKETS)
-
-#endif // ASIO_DETAIL_CONFIG_HPP

ext/asio/asio/detail/consuming_buffers.hpp

@@ -1,278 +0,0 @@
-//
-// detail/consuming_buffers.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_CONSUMING_BUFFERS_HPP
-#define ASIO_DETAIL_CONSUMING_BUFFERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include <boost/iterator.hpp>
-#include <boost/limits.hpp>
-#include "asio/buffer.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-// A proxy iterator for a sub-range in a list of buffers.
-template <typename Buffer, typename Buffer_Iterator>
-class consuming_buffers_iterator
-  : public boost::iterator<std::forward_iterator_tag, const Buffer>
-{
-public:
-  // Default constructor creates an end iterator.
-  consuming_buffers_iterator()
-    : at_end_(true)
-  {
-  }
-
-  // Construct with a buffer for the first entry and an iterator
-  // range for the remaining entries.
-  consuming_buffers_iterator(bool at_end, const Buffer& first,
-      Buffer_Iterator begin_remainder, Buffer_Iterator end_remainder,
-      std::size_t max_size)
-    : at_end_(max_size > 0 ? at_end : true),
-      first_(buffer(first, max_size)),
-      begin_remainder_(begin_remainder),
-      end_remainder_(end_remainder),
-      offset_(0),
-      max_size_(max_size)
-  {
-  }
-
-  // Dereference an iterator.
-  const Buffer& operator*() const
-  {
-    return dereference();
-  }
-
-  // Dereference an iterator.
-  const Buffer* operator->() const
-  {
-    return &dereference();
-  }
-
-  // Increment operator (prefix).
-  consuming_buffers_iterator& operator++()
-  {
-    increment();
-    return *this;
-  }
-
-  // Increment operator (postfix).
-  consuming_buffers_iterator operator++(int)
-  {
-    consuming_buffers_iterator tmp(*this);
-    ++*this;
-    return tmp;
-  }
-
-  // Test two iterators for equality.
-  friend bool operator==(const consuming_buffers_iterator& a,
-      const consuming_buffers_iterator& b)
-  {
-    return a.equal(b);
-  }
-
-  // Test two iterators for inequality.
-  friend bool operator!=(const consuming_buffers_iterator& a,
-      const consuming_buffers_iterator& b)
-  {
-    return !a.equal(b);
-  }
-
-private:
-  void increment()
-  {
-    if (!at_end_)
-    {
-      if (begin_remainder_ == end_remainder_
-          || offset_ + buffer_size(first_) >= max_size_)
-      {
-        at_end_ = true;
-      }
-      else
-      {
-        offset_ += buffer_size(first_);
-        first_ = buffer(*begin_remainder_++, max_size_ - offset_);
-      }
-    }
-  }
-
-  bool equal(const consuming_buffers_iterator& other) const
-  {
-    if (at_end_ && other.at_end_)
-      return true;
-    return !at_end_ && !other.at_end_
-      && buffer_cast<const void*>(first_)
-        == buffer_cast<const void*>(other.first_)
-      && buffer_size(first_) == buffer_size(other.first_)
-      && begin_remainder_ == other.begin_remainder_
-      && end_remainder_ == other.end_remainder_;
-  }
-
-  const Buffer& dereference() const
-  {
-    return first_;
-  }
-
-  bool at_end_;
-  Buffer first_;
-  Buffer_Iterator begin_remainder_;
-  Buffer_Iterator end_remainder_;
-  std::size_t offset_;
-  std::size_t max_size_;
-};
-
-// A proxy for a sub-range in a list of buffers.
-template <typename Buffer, typename Buffers>
-class consuming_buffers
-{
-public:
-  // The type for each element in the list of buffers.
-  typedef Buffer value_type;
-
-  // A forward-only iterator type that may be used to read elements.
-  typedef consuming_buffers_iterator<Buffer, typename Buffers::const_iterator>
-    const_iterator;
-
-  // Construct to represent the entire list of buffers.
-  consuming_buffers(const Buffers& buffers)
-    : buffers_(buffers),
-      at_end_(buffers_.begin() == buffers_.end()),
-      begin_remainder_(buffers_.begin()),
-      max_size_((std::numeric_limits<std::size_t>::max)())
-  {
-    if (!at_end_)
-    {
-      first_ = *buffers_.begin();
-      ++begin_remainder_;
-    }
-  }
-
-  // Copy constructor.
-  consuming_buffers(const consuming_buffers& other)
-    : buffers_(other.buffers_),
-      at_end_(other.at_end_),
-      first_(other.first_),
-      begin_remainder_(buffers_.begin()),
-      max_size_(other.max_size_)
-  {
-    typename Buffers::const_iterator first = other.buffers_.begin();
-    typename Buffers::const_iterator second = other.begin_remainder_;
-    std::advance(begin_remainder_, std::distance(first, second));
-  }
-
-  // Assignment operator.
-  consuming_buffers& operator=(const consuming_buffers& other)
-  {
-    buffers_ = other.buffers_;
-    at_end_ = other.at_end_;
-    first_ = other.first_;
-    begin_remainder_ = buffers_.begin();
-    typename Buffers::const_iterator first = other.buffers_.begin();
-    typename Buffers::const_iterator second = other.begin_remainder_;
-    std::advance(begin_remainder_, std::distance(first, second));
-    max_size_ = other.max_size_;
-    return *this;
-  }
-
-  // Get a forward-only iterator to the first element.
-  const_iterator begin() const
-  {
-    return const_iterator(at_end_, first_,
-        begin_remainder_, buffers_.end(), max_size_);
-  }
-
-  // Get a forward-only iterator for one past the last element.
-  const_iterator end() const
-  {
-    return const_iterator();
-  }
-
-  // Set the maximum size for a single transfer.
-  void prepare(std::size_t max_size)
-  {
-    max_size_ = max_size;
-  }
-
-  // Consume the specified number of bytes from the buffers.
-  void consume(std::size_t size)
-  {
-    // Remove buffers from the start until the specified size is reached.
-    while (size > 0 && !at_end_)
-    {
-      if (buffer_size(first_) <= size)
-      {
-        size -= buffer_size(first_);
-        if (begin_remainder_ == buffers_.end())
-          at_end_ = true;
-        else
-          first_ = *begin_remainder_++;
-      }
-      else
-      {
-        first_ = first_ + size;
-        size = 0;
-      }
-    }
-
-    // Remove any more empty buffers at the start.
-    while (!at_end_ && buffer_size(first_) == 0)
-    {
-      if (begin_remainder_ == buffers_.end())
-        at_end_ = true;
-      else
-        first_ = *begin_remainder_++;
-    }
-  }
-
-private:
-  Buffers buffers_;
-  bool at_end_;
-  Buffer first_;
-  typename Buffers::const_iterator begin_remainder_;
-  std::size_t max_size_;
-};
-
-// Specialisation for null_buffers to ensure that the null_buffers type is
-// always passed through to the underlying read or write operation.
-template <typename Buffer>
-class consuming_buffers<Buffer, asio::null_buffers>
-  : public asio::null_buffers
-{
-public:
-  consuming_buffers(const asio::null_buffers&)
-  {
-    // No-op.
-  }
-
-  void prepare(std::size_t)
-  {
-    // No-op.
-  }
-
-  void consume(std::size_t)
-  {
-    // No-op.
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_CONSUMING_BUFFERS_HPP

ext/asio/asio/detail/deadline_timer_service.hpp

@@ -1,186 +0,0 @@
-//
-// detail/deadline_timer_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
-#define ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cstddef>
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/noncopyable.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_op.hpp"
-#include "asio/detail/timer_queue.hpp"
-#include "asio/detail/timer_scheduler.hpp"
-#include "asio/detail/wait_handler.hpp"
-
-#include "asio/detail/push_options.hpp"
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-class deadline_timer_service
-{
-public:
-  // The time type.
-  typedef typename Time_Traits::time_type time_type;
-
-  // The duration type.
-  typedef typename Time_Traits::duration_type duration_type;
-
-  // The implementation type of the timer. This type is dependent on the
-  // underlying implementation of the timer service.
-  struct implementation_type
-    : private asio::detail::noncopyable
-  {
-    time_type expiry;
-    bool might_have_pending_waits;
-    typename timer_queue<Time_Traits>::per_timer_data timer_data;
-  };
-
-  // Constructor.
-  deadline_timer_service(asio::io_service& io_service)
-    : scheduler_(asio::use_service<timer_scheduler>(io_service))
-  {
-    scheduler_.init_task();
-    scheduler_.add_timer_queue(timer_queue_);
-  }
-
-  // Destructor.
-  ~deadline_timer_service()
-  {
-    scheduler_.remove_timer_queue(timer_queue_);
-  }
-
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-  }
-
-  // Construct a new timer implementation.
-  void construct(implementation_type& impl)
-  {
-    impl.expiry = time_type();
-    impl.might_have_pending_waits = false;
-  }
-
-  // Destroy a timer implementation.
-  void destroy(implementation_type& impl)
-  {
-    asio::error_code ec;
-    cancel(impl, ec);
-  }
-
-  // Cancel any asynchronous wait operations associated with the timer.
-  std::size_t cancel(implementation_type& impl, asio::error_code& ec)
-  {
-    if (!impl.might_have_pending_waits)
-    {
-      ec = asio::error_code();
-      return 0;
-    }
-    std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
-    impl.might_have_pending_waits = false;
-    ec = asio::error_code();
-    return count;
-  }
-
-  // Get the expiry time for the timer as an absolute time.
-  time_type expires_at(const implementation_type& impl) const
-  {
-    return impl.expiry;
-  }
-
-  // Set the expiry time for the timer as an absolute time.
-  std::size_t expires_at(implementation_type& impl,
-      const time_type& expiry_time, asio::error_code& ec)
-  {
-    std::size_t count = cancel(impl, ec);
-    impl.expiry = expiry_time;
-    ec = asio::error_code();
-    return count;
-  }
-
-  // Get the expiry time for the timer relative to now.
-  duration_type expires_from_now(const implementation_type& impl) const
-  {
-    return Time_Traits::subtract(expires_at(impl), Time_Traits::now());
-  }
-
-  // Set the expiry time for the timer relative to now.
-  std::size_t expires_from_now(implementation_type& impl,
-      const duration_type& expiry_time, asio::error_code& ec)
-  {
-    return expires_at(impl,
-        Time_Traits::add(Time_Traits::now(), expiry_time), ec);
-  }
-
-  // Perform a blocking wait on the timer.
-  void wait(implementation_type& impl, asio::error_code& ec)
-  {
-    time_type now = Time_Traits::now();
-    while (Time_Traits::less_than(now, impl.expiry))
-    {
-      boost::posix_time::time_duration timeout =
-        Time_Traits::to_posix_duration(Time_Traits::subtract(impl.expiry, now));
-      ::timeval tv;
-      tv.tv_sec = timeout.total_seconds();
-      tv.tv_usec = timeout.total_microseconds() % 1000000;
-      asio::error_code ec;
-      socket_ops::select(0, 0, 0, 0, &tv, ec);
-      now = Time_Traits::now();
-    }
-    ec = asio::error_code();
-  }
-
-  // Start an asynchronous wait on the timer.
-  template <typename Handler>
-  void async_wait(implementation_type& impl, Handler handler)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef wait_handler<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
-      asio_handler_alloc_helpers::allocate(
-        sizeof(op), handler), 0 };
-    p.p = new (p.v) op(handler);
-
-    impl.might_have_pending_waits = true;
-
-    scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
-    p.v = p.p = 0;
-  }
-
-private:
-  // The queue of timers.
-  timer_queue<Time_Traits> timer_queue_;
-
-  // The object that schedules and executes timers. Usually a reactor.
-  timer_scheduler& scheduler_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP

ext/asio/asio/detail/descriptor_ops.hpp

@@ -1,105 +0,0 @@
-//
-// detail/descriptor_ops.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DESCRIPTOR_OPS_HPP
-#define ASIO_DETAIL_DESCRIPTOR_OPS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include <cstddef>
-#include "asio/error_code.hpp"
-#include "asio/detail/socket_types.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace descriptor_ops {
-
-// Descriptor state bits.
-enum
-{
-  // The user wants a non-blocking descriptor.
-  user_set_non_blocking = 1,
-
-  // The descriptor has been set non-blocking.
-  internal_non_blocking = 2,
-
-  // Helper "state" used to determine whether the descriptor is non-blocking.
-  non_blocking = user_set_non_blocking | internal_non_blocking
-};
-
-typedef unsigned char state_type;
-
-template <typename ReturnType>
-inline ReturnType error_wrapper(ReturnType return_value,
-    asio::error_code& ec)
-{
-  ec = asio::error_code(errno,
-      asio::error::get_system_category());
-  return return_value;
-}
-
-ASIO_DECL int open(const char* path, int flags,
-    asio::error_code& ec);
-
-ASIO_DECL int close(int d, state_type& state,
-    asio::error_code& ec);
-
-ASIO_DECL bool set_internal_non_blocking(int d,
-    state_type& state, asio::error_code& ec);
-
-typedef iovec buf;
-
-ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs,
-    std::size_t count, bool all_empty, asio::error_code& ec);
-
-ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-ASIO_DECL std::size_t sync_write(int d, state_type state,
-    const buf* bufs, std::size_t count, bool all_empty,
-    asio::error_code& ec);
-
-ASIO_DECL bool non_blocking_write(int d,
-    const buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred);
-
-ASIO_DECL int ioctl(int d, state_type& state, long cmd,
-    ioctl_arg_type* arg, asio::error_code& ec);
-
-ASIO_DECL int fcntl(int d, long cmd, asio::error_code& ec);
-
-ASIO_DECL int fcntl(int d, long cmd,
-    long arg, asio::error_code& ec);
-
-ASIO_DECL int poll_read(int d, asio::error_code& ec);
-
-ASIO_DECL int poll_write(int d, asio::error_code& ec);
-
-} // namespace descriptor_ops
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/descriptor_ops.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_DESCRIPTOR_OPS_HPP

ext/asio/asio/detail/descriptor_read_op.hpp

@@ -1,114 +0,0 @@
-//
-// detail/descriptor_read_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
-#define ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include <boost/utility/addressof.hpp>
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/reactor_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class descriptor_read_op_base : public reactor_op
-{
-public:
-  descriptor_read_op_base(int descriptor,
-      const MutableBufferSequence& buffers, func_type complete_func)
-    : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      buffers_(buffers)
-  {
-  }
-
-  static bool do_perform(reactor_op* base)
-  {
-    descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
-
-    buffer_sequence_adapter<asio::mutable_buffer,
-        MutableBufferSequence> bufs(o->buffers_);
-
-    return descriptor_ops::non_blocking_read(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
-  }
-
-private:
-  int descriptor_;
-  MutableBufferSequence buffers_;
-};
-
-template <typename MutableBufferSequence, typename Handler>
-class descriptor_read_op
-  : public descriptor_read_op_base<MutableBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
-
-  descriptor_read_op(int descriptor,
-      const MutableBufferSequence& buffers, Handler handler)
-    : descriptor_read_op_base<MutableBufferSequence>(
-        descriptor, buffers, &descriptor_read_op::do_complete),
-      handler_(handler)
-  {
-  }
-
-  static void do_complete(io_service_impl* owner, operation* base,
-      asio::error_code /*ec*/, std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      asio::detail::fenced_block b;
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-    }
-  }
-
-private:
-  Handler handler_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP

ext/asio/asio/detail/descriptor_write_op.hpp

@@ -1,114 +0,0 @@
-//
-// detail/descriptor_write_op.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
-#define ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include <boost/utility/addressof.hpp>
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/buffer_sequence_adapter.hpp"
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/reactor_op.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename ConstBufferSequence>
-class descriptor_write_op_base : public reactor_op
-{
-public:
-  descriptor_write_op_base(int descriptor,
-      const ConstBufferSequence& buffers, func_type complete_func)
-    : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
-      descriptor_(descriptor),
-      buffers_(buffers)
-  {
-  }
-
-  static bool do_perform(reactor_op* base)
-  {
-    descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
-
-    buffer_sequence_adapter<asio::const_buffer,
-        ConstBufferSequence> bufs(o->buffers_);
-
-    return descriptor_ops::non_blocking_write(o->descriptor_,
-        bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
-  }
-
-private:
-  int descriptor_;
-  ConstBufferSequence buffers_;
-};
-
-template <typename ConstBufferSequence, typename Handler>
-class descriptor_write_op
-  : public descriptor_write_op_base<ConstBufferSequence>
-{
-public:
-  ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
-
-  descriptor_write_op(int descriptor,
-      const ConstBufferSequence& buffers, Handler handler)
-    : descriptor_write_op_base<ConstBufferSequence>(
-        descriptor, buffers, &descriptor_write_op::do_complete),
-      handler_(handler)
-  {
-  }
-
-  static void do_complete(io_service_impl* owner, operation* base,
-      asio::error_code /*ec*/, std::size_t /*bytes_transferred*/)
-  {
-    // Take ownership of the handler object.
-    descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
-
-    // Make a copy of the handler so that the memory can be deallocated before
-    // the upcall is made. Even if we're not about to make an upcall, a
-    // sub-object of the handler may be the true owner of the memory associated
-    // with the handler. Consequently, a local copy of the handler is required
-    // to ensure that any owning sub-object remains valid until after we have
-    // deallocated the memory here.
-    detail::binder2<Handler, asio::error_code, std::size_t>
-      handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
-    p.reset();
-
-    // Make the upcall if required.
-    if (owner)
-    {
-      asio::detail::fenced_block b;
-      asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-    }
-  }
-
-private:
-  Handler handler_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP

ext/asio/asio/detail/dev_poll_reactor.hpp

@@ -1,185 +0,0 @@
-//
-// detail/dev_poll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DEV_POLL_REACTOR_HPP
-#define ASIO_DETAIL_DEV_POLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-#include <cstddef>
-#include <vector>
-#include <sys/devpoll.h>
-#include "asio/detail/dev_poll_reactor_fwd.hpp"
-#include "asio/detail/hash_map.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/reactor_op_queue.hpp"
-#include "asio/detail/select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_op.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_fwd.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-#include "asio/io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class dev_poll_reactor
-  : public asio::detail::service_base<dev_poll_reactor>
-{
-public:
-  enum { read_op = 0, write_op = 1,
-    connect_op = 1, except_op = 2, max_ops = 3 };
-
-  // Per-descriptor data.
-  struct per_descriptor_data
-  {
-  };
-
-  // Constructor.
-  ASIO_DECL dev_poll_reactor(asio::io_service& io_service);
-
-  // Destructor.
-  ASIO_DECL ~dev_poll_reactor();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
-
-  // Initialise the task.
-  ASIO_DECL void init_task();
-
-  // Register a socket with the reactor. Returns 0 on success, system error
-  // code on failure.
-  ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
-
-  // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op)
-  {
-    io_service_.post_immediate_completion(op);
-  }
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data&, reactor_op* op, bool allow_speculative);
-
-  // Cancel all operations associated with the given descriptor. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
-  ASIO_DECL void close_descriptor(
-      socket_type descriptor, per_descriptor_data&);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
-
-  // Run /dev/poll once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(bool block, op_queue<operation>& ops);
-
-  // Interrupt the select loop.
-  ASIO_DECL void interrupt();
-
-private:
-  // Create the /dev/poll file descriptor. Throws an exception if the descriptor
-  // cannot be created.
-  ASIO_DECL static int do_dev_poll_create();
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Get the timeout value for the /dev/poll DP_POLL operation. The timeout
-  // value is returned as a number of milliseconds. A return value of -1
-  // indicates that the poll should block indefinitely.
-  ASIO_DECL int get_timeout();
-
-  // Cancel all operations associated with the given descriptor. The do_cancel
-  // function of the handler objects will be invoked. This function does not
-  // acquire the dev_poll_reactor's mutex.
-  ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
-      const asio::error_code& ec);
-
-  // Add a pending event entry for the given descriptor.
-  ASIO_DECL ::pollfd& add_pending_event_change(int descriptor);
-
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
-
-  // Mutex to protect access to internal data.
-  asio::detail::mutex mutex_;
-
-  // The /dev/poll file descriptor.
-  int dev_poll_fd_;
-
-  // Vector of /dev/poll events waiting to be written to the descriptor.
-  std::vector< ::pollfd> pending_event_changes_;
-
-  // Hash map to associate a descriptor with a pending event change index.
-  hash_map<int, std::size_t> pending_event_change_index_;
-
-  // The interrupter is used to break a blocking DP_POLL operation.
-  select_interrupter interrupter_;
-
-  // The queues of read, write and except operations.
-  reactor_op_queue<socket_type> op_queue_[max_ops];
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/dev_poll_reactor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/dev_poll_reactor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_DEV_POLL_REACTOR_HPP

ext/asio/asio/detail/dev_poll_reactor_fwd.hpp

@@ -1,32 +0,0 @@
-//
-// detail/dev_poll_reactor_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP
-#define ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-namespace asio {
-namespace detail {
-
-class dev_poll_reactor;
-
-} // namespace detail
-} // namespace asio
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP

ext/asio/asio/detail/epoll_reactor.hpp

@@ -1,197 +0,0 @@
-//
-// detail/epoll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EPOLL_REACTOR_HPP
-#define ASIO_DETAIL_EPOLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include "asio/io_service.hpp"
-#include "asio/detail/epoll_reactor_fwd.hpp"
-#include "asio/detail/mutex.hpp"
-#include "asio/detail/object_pool.hpp"
-#include "asio/detail/op_queue.hpp"
-#include "asio/detail/reactor_op.hpp"
-#include "asio/detail/select_interrupter.hpp"
-#include "asio/detail/socket_types.hpp"
-#include "asio/detail/timer_op.hpp"
-#include "asio/detail/timer_queue_base.hpp"
-#include "asio/detail/timer_queue_fwd.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class epoll_reactor
-  : public asio::detail::service_base<epoll_reactor>
-{
-public:
-  enum { read_op = 0, write_op = 1,
-    connect_op = 1, except_op = 2, max_ops = 3 };
-
-  // Per-descriptor queues.
-  class descriptor_state
-  {
-    friend class epoll_reactor;
-    friend class object_pool_access;
-    mutex mutex_;
-    op_queue<reactor_op> op_queue_[max_ops];
-    bool shutdown_;
-    descriptor_state* next_;
-    descriptor_state* prev_;
-  };
-
-  // Per-descriptor data.
-  typedef descriptor_state* per_descriptor_data;
-
-  // Constructor.
-  ASIO_DECL epoll_reactor(asio::io_service& io_service);
-
-  // Destructor.
-  ASIO_DECL ~epoll_reactor();
-
-  // Destroy all user-defined handler objects owned by the service.
-  ASIO_DECL void shutdown_service();
-
-  // Initialise the task.
-  ASIO_DECL void init_task();
-
-  // Register a socket with the reactor. Returns 0 on success, system error
-  // code on failure.
-  ASIO_DECL int register_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op)
-  {
-    io_service_.post_immediate_completion(op);
-  }
-
-  // Start a new operation. The reactor operation will be performed when the
-  // given descriptor is flagged as ready, or an error has occurred.
-  ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      reactor_op* op, bool allow_speculative);
-
-  // Cancel all operations associated with the given descriptor. The
-  // handlers associated with the descriptor will be invoked with the
-  // operation_aborted error.
-  ASIO_DECL void cancel_ops(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
-  ASIO_DECL void close_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data);
-
-  // Add a new timer queue to the reactor.
-  template <typename Time_Traits>
-  void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Remove a timer queue from the reactor.
-  template <typename Time_Traits>
-  void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
-
-  // Schedule a new operation in the given timer queue to expire at the
-  // specified absolute time.
-  template <typename Time_Traits>
-  void schedule_timer(timer_queue<Time_Traits>& queue,
-      const typename Time_Traits::time_type& time,
-      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op);
-
-  // Cancel the timer operations associated with the given token. Returns the
-  // number of operations that have been posted or dispatched.
-  template <typename Time_Traits>
-  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
-      typename timer_queue<Time_Traits>::per_timer_data& timer);
-
-  // Run epoll once until interrupted or events are ready to be dispatched.
-  ASIO_DECL void run(bool block, op_queue<operation>& ops);
-
-  // Interrupt the select loop.
-  ASIO_DECL void interrupt();
-
-private:
-  // The hint to pass to epoll_create to size its data structures.
-  enum { epoll_size = 20000 };
-
-  // Create the epoll file descriptor. Throws an exception if the descriptor
-  // cannot be created.
-  ASIO_DECL static int do_epoll_create();
-
-  // Helper function to add a new timer queue.
-  ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
-
-  // Helper function to remove a timer queue.
-  ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
-
-  // Called to recalculate and update the timeout.
-  ASIO_DECL void update_timeout();
-
-  // Get the timeout value for the epoll_wait call. The timeout value is
-  // returned as a number of milliseconds. A return value of -1 indicates
-  // that epoll_wait should block indefinitely.
-  ASIO_DECL int get_timeout();
-
-#if defined(ASIO_HAS_TIMERFD)
-  // Get the timeout value for the timer descriptor. The return value is the
-  // flag argument to be used when calling timerfd_settime.
-  ASIO_DECL int get_timeout(itimerspec& ts);
-#endif // defined(ASIO_HAS_TIMERFD)
-
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
-
-  // Mutex to protect access to internal data.
-  mutex mutex_;
-
-  // The epoll file descriptor.
-  int epoll_fd_;
-
-  // The timer file descriptor.
-  int timer_fd_;
-
-  // The interrupter is used to break a blocking epoll_wait call.
-  select_interrupter interrupter_;
-
-  // The timer queues.
-  timer_queue_set timer_queues_;
-
-  // Whether the service has been shut down.
-  bool shutdown_;
-
-  // Mutex to protect access to the registered descriptors.
-  mutex registered_descriptors_mutex_;
-
-  // Keep track of all registered descriptors.
-  object_pool<descriptor_state> registered_descriptors_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#include "asio/detail/impl/epoll_reactor.hpp"
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/epoll_reactor.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_EPOLL_REACTOR_HPP

ext/asio/asio/detail/epoll_reactor_fwd.hpp

@@ -1,32 +0,0 @@
-//
-// detail/epoll_reactor_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
-#define ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EPOLL)
-
-namespace asio {
-namespace detail {
-
-class epoll_reactor;
-
-} // namespace detail
-} // namespace asio
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP

ext/asio/asio/detail/event.hpp

@@ -1,44 +0,0 @@
-//
-// detail/event.hpp
-// ~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EVENT_HPP
-#define ASIO_DETAIL_EVENT_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_HAS_THREADS) || defined(ASIO_DISABLE_THREADS)
-# include "asio/detail/null_event.hpp"
-#elif defined(BOOST_WINDOWS)
-# include "asio/detail/win_event.hpp"
-#elif defined(BOOST_HAS_PTHREADS)
-# include "asio/detail/posix_event.hpp"
-#else
-# error Only Windows and POSIX are supported!
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(BOOST_HAS_THREADS) || defined(ASIO_DISABLE_THREADS)
-typedef null_event event;
-#elif defined(BOOST_WINDOWS)
-typedef win_event event;
-#elif defined(BOOST_HAS_PTHREADS)
-typedef posix_event event;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_EVENT_HPP

ext/asio/asio/detail/eventfd_select_interrupter.hpp

@@ -1,74 +0,0 @@
-//
-// detail/eventfd_select_interrupter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
-#define ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EVENTFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class eventfd_select_interrupter
-{
-public:
-  // Constructor.
-  ASIO_DECL eventfd_select_interrupter();
-
-  // Destructor.
-  ASIO_DECL ~eventfd_select_interrupter();
-
-  // Interrupt the select call.
-  ASIO_DECL void interrupt();
-
-  // Reset the select interrupt. Returns true if the call was interrupted.
-  ASIO_DECL bool reset();
-
-  // Get the read descriptor to be passed to select.
-  int read_descriptor() const
-  {
-    return read_descriptor_;
-  }
-
-private:
-  // The read end of a connection used to interrupt the select call. This file
-  // descriptor is passed to select such that when it is time to stop, a single
-  // 64bit value will be written on the other end of the connection and this
-  // descriptor will become readable.
-  int read_descriptor_;
-
-  // The write end of a connection used to interrupt the select call. A single
-  // 64bit non-zero value may be written to this to wake up the select which is
-  // waiting for the other end to become readable. This descriptor will only
-  // differ from the read descriptor when a pipe is used.
-  int write_descriptor_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#if defined(ASIO_HEADER_ONLY)
-# include "asio/detail/impl/eventfd_select_interrupter.ipp"
-#endif // defined(ASIO_HEADER_ONLY)
-
-#endif // defined(ASIO_HAS_EVENTFD)
-
-#endif // ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP

ext/asio/asio/detail/fd_set_adapter.hpp

@@ -1,34 +0,0 @@
-//
-// detail/fd_set_adapter.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_FD_SET_ADAPTER_HPP
-#define ASIO_DETAIL_FD_SET_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/posix_fd_set_adapter.hpp"
-#include "asio/detail/win_fd_set_adapter.hpp"
-
-namespace asio {
-namespace detail {
-
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-typedef win_fd_set_adapter fd_set_adapter;
-#else
-typedef posix_fd_set_adapter fd_set_adapter;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_FD_SET_ADAPTER_HPP

ext/asio/asio/detail/fenced_block.hpp

@@ -1,76 +0,0 @@
-//
-// detail/fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_HAS_THREADS) \
-  || defined(ASIO_DISABLE_THREADS) \
-  || defined(ASIO_DISABLE_FENCED_BLOCK)
-# include "asio/detail/null_fenced_block.hpp"
-#elif defined(__MACH__) && defined(__APPLE__)
-# include "asio/detail/macos_fenced_block.hpp"
-#elif defined(__sun)
-# include "asio/detail/solaris_fenced_block.hpp"
-#elif defined(__GNUC__) && defined(__arm__)
-# include "asio/detail/gcc_arm_fenced_block.hpp"
-#elif defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
-# include "asio/detail/gcc_hppa_fenced_block.hpp"
-#elif defined(__GNUC__) \
-  && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
-  && !defined(__INTEL_COMPILER) && !defined(__ICL) \
-  && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
-# include "asio/detail/gcc_sync_fenced_block.hpp"
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-# include "asio/detail/gcc_x86_fenced_block.hpp"
-#elif defined(BOOST_WINDOWS) && !defined(UNDER_CE)
-# include "asio/detail/win_fenced_block.hpp"
-#else
-# include "asio/detail/null_fenced_block.hpp"
-#endif
-
-namespace asio {
-namespace detail {
-
-#if !defined(BOOST_HAS_THREADS) \
-  || defined(ASIO_DISABLE_THREADS) \
-  || defined(ASIO_DISABLE_FENCED_BLOCK)
-typedef null_fenced_block fenced_block;
-#elif defined(__MACH__) && defined(__APPLE__)
-typedef macos_fenced_block fenced_block;
-#elif defined(__sun)
-typedef solaris_fenced_block fenced_block;
-#elif defined(__GNUC__) && defined(__arm__)
-typedef gcc_arm_fenced_block fenced_block;
-#elif defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
-typedef gcc_hppa_fenced_block fenced_block;
-#elif defined(__GNUC__) \
-  && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
-  && !defined(__INTEL_COMPILER) && !defined(__ICL) \
-  && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
-typedef gcc_sync_fenced_block fenced_block;
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-typedef gcc_x86_fenced_block fenced_block;
-#elif defined(BOOST_WINDOWS) && !defined(UNDER_CE)
-typedef win_fenced_block fenced_block;
-#else
-typedef null_fenced_block fenced_block;
-#endif
-
-} // namespace detail
-} // namespace asio
-
-#endif // ASIO_DETAIL_FENCED_BLOCK_HPP

ext/asio/asio/detail/gcc_arm_fenced_block.hpp

@@ -1,76 +0,0 @@
-//
-// detail/gcc_arm_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(__GNUC__) && defined(__arm__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class gcc_arm_fenced_block
-  : private noncopyable
-{
-public:
-  // Constructor.
-  gcc_arm_fenced_block()
-  {
-    barrier();
-  }
-
-  // Destructor.
-  ~gcc_arm_fenced_block()
-  {
-    barrier();
-  }
-
-private:
-  static void barrier()
-  {
-#if defined(__ARM_ARCH_4__) \
-    || defined(__ARM_ARCH_4T__) \
-    || defined(__ARM_ARCH_5__) \
-    || defined(__ARM_ARCH_5E__) \
-    || defined(__ARM_ARCH_5T__) \
-    || defined(__ARM_ARCH_5TE__) \
-    || defined(__ARM_ARCH_5TEJ__) \
-    || defined(__ARM_ARCH_6__) \
-    || defined(__ARM_ARCH_6J__) \
-    || defined(__ARM_ARCH_6K__) \
-    || defined(__ARM_ARCH_6Z__) \
-    || defined(__ARM_ARCH_6ZK__) \
-    || defined(__ARM_ARCH_6T2__)
-    int a = 0, b = 0;
-    __asm__ __volatile__ ("swp %0, %1, [%2]"
-        : "=&r"(a) : "r"(1), "r"(&b) : "memory", "cc");
-#else
-    // ARMv7 and later.
-    __asm__ __volatile__ ("dmb" : : : "memory");
-#endif
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(__GNUC__) && defined(__arm__)
-
-#endif // ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP

ext/asio/asio/detail/gcc_fenced_block.hpp

@@ -1,63 +0,0 @@
-//
-// gcc_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_GCC_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_GCC_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-#include "asio/detail/push_options.hpp"
-#include <boost/config.hpp>
-#include "asio/detail/pop_options.hpp"
-
-#if defined(__GNUC__) \
-  && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
-  && !defined(__INTEL_COMPILER) && !defined(__ICL) \
-  && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
-
-namespace asio {
-namespace detail {
-
-class gcc_fenced_block
-  : private noncopyable
-{
-public:
-  // Constructor.
-  gcc_fenced_block()
-    : value_(0)
-  {
-    __sync_lock_test_and_set(&value_, 1);
-  }
-
-  // Destructor.
-  ~gcc_fenced_block()
-  {
-    __sync_lock_release(&value_);
-  }
-
-private:
-  int value_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#endif // defined(__GNUC__)
-       // && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4))
-       // && !defined(__INTEL_COMPILER) && !defined(__ICL)
-       // && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_GCC_FENCED_BLOCK_HPP

ext/asio/asio/detail/gcc_hppa_fenced_block.hpp

@@ -1,58 +0,0 @@
-//
-// detail/gcc_hppa_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_GCC_HPPA_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_GCC_HPPA_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class gcc_hppa_fenced_block
-  : private noncopyable
-{
-public:
-  // Constructor.
-  gcc_hppa_fenced_block()
-  {
-    barrier();
-  }
-
-  // Destructor.
-  ~gcc_hppa_fenced_block()
-  {
-    barrier();
-  }
-
-private:
-  static void barrier()
-  {
-    // This is just a placeholder and almost certainly not sufficient.
-    __asm__ __volatile__ ("" : : : "memory");
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
-
-#endif // ASIO_DETAIL_GCC_HPPA_FENCED_BLOCK_HPP

ext/asio/asio/detail/gcc_sync_fenced_block.hpp

@@ -1,61 +0,0 @@
-//
-// detail/gcc_sync_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(__GNUC__) \
-  && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
-  && !defined(__INTEL_COMPILER) && !defined(__ICL) \
-  && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class gcc_sync_fenced_block
-  : private noncopyable
-{
-public:
-  // Constructor.
-  gcc_sync_fenced_block()
-    : value_(0)
-  {
-    __sync_lock_test_and_set(&value_, 1);
-  }
-
-  // Destructor.
-  ~gcc_sync_fenced_block()
-  {
-    __sync_lock_release(&value_);
-  }
-
-private:
-  int value_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(__GNUC__)
-       // && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4))
-       // && !defined(__INTEL_COMPILER) && !defined(__ICL)
-       // && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
-
-#endif // ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP

ext/asio/asio/detail/gcc_x86_fenced_block.hpp

@@ -1,59 +0,0 @@
-//
-// detail/gcc_x86_fenced_block.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
-#define ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class gcc_x86_fenced_block
-  : private noncopyable
-{
-public:
-  // Constructor.
-  gcc_x86_fenced_block()
-  {
-    barrier();
-  }
-
-  // Destructor.
-  ~gcc_x86_fenced_block()
-  {
-    barrier();
-  }
-
-private:
-  static int barrier()
-  {
-    int r = 0;
-    __asm__ __volatile__ ("xchgl %%eax, %0" : "=m" (r) : : "memory", "cc");
-    return r;
-  }
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-
-#endif // ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP

ext/asio/asio/detail/handler_alloc_helpers.hpp

@@ -1,85 +0,0 @@
-//
-// detail/handler_alloc_helpers.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
-#define ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/addressof.hpp>
-#include "asio/detail/noncopyable.hpp"
-#include "asio/handler_alloc_hook.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-// Calls to asio_handler_allocate and asio_handler_deallocate must be made from
-// a namespace that does not contain any overloads of these functions. The
-// asio_handler_alloc_helpers namespace is defined here for that purpose.
-namespace asio_handler_alloc_helpers {
-
-template <typename Handler>
-inline void* allocate(std::size_t s, Handler& h)
-{
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
-  return ::operator new(s);
-#else
-  using namespace asio;
-  return asio_handler_allocate(s, boost::addressof(h));
-#endif
-}
-
-template <typename Handler>
-inline void deallocate(void* p, std::size_t s, Handler& h)
-{
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
-  ::operator delete(p);
-#else
-  using namespace asio;
-  asio_handler_deallocate(p, s, boost::addressof(h));
-#endif
-}
-
-} // namespace asio_handler_alloc_helpers
-
-#define ASIO_DEFINE_HANDLER_PTR(op) \
-  struct ptr \
-  { \
-    Handler* h; \
-    void* v; \
-    op* p; \
-    ~ptr() \
-    { \
-      reset(); \
-    } \
-    void reset() \
-    { \
-      if (p) \
-      { \
-        p->~op(); \
-        p = 0; \
-      } \
-      if (v) \
-      { \
-        asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); \
-        v = 0; \
-      } \
-    } \
-  } \
-  /**/
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP

ext/asio/asio/detail/handler_invoke_helpers.hpp

@@ -1,47 +0,0 @@
-//
-// detail/handler_invoke_helpers.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
-#define ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/addressof.hpp>
-#include "asio/handler_invoke_hook.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-// Calls to asio_handler_invoke must be made from a namespace that does not
-// contain overloads of this function. The asio_handler_invoke_helpers
-// namespace is defined here for that purpose.
-namespace asio_handler_invoke_helpers {
-
-template <typename Function, typename Context>
-inline void invoke(const Function& function, Context& context)
-{
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
-  Function tmp(function);
-  tmp();
-#else
-  using namespace asio;
-  asio_handler_invoke(function, boost::addressof(context));
-#endif
-}
-
-} // namespace asio_handler_invoke_helpers
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP

ext/asio/asio/detail/hash_map.hpp

@@ -1,329 +0,0 @@
-//
-// detail/hash_map.hpp
-// ~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_HASH_MAP_HPP
-#define ASIO_DETAIL_HASH_MAP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cassert>
-#include <list>
-#include <utility>
-#include "asio/detail/noncopyable.hpp"
-
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# include "asio/detail/socket_types.hpp"
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline std::size_t calculate_hash_value(int i)
-{
-  return static_cast<std::size_t>(i);
-}
-
-inline std::size_t calculate_hash_value(void* p)
-{
-  return reinterpret_cast<std::size_t>(p)
-    + (reinterpret_cast<std::size_t>(p) >> 3);
-}
-
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-inline std::size_t calculate_hash_value(SOCKET s)
-{
-  return static_cast<std::size_t>(s);
-}
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-// Note: assumes K and V are POD types.
-template <typename K, typename V>
-class hash_map
-  : private noncopyable
-{
-public:
-  // The type of a value in the map.
-  typedef std::pair<K, V> value_type;
-
-  // The type of a non-const iterator over the hash map.
-  typedef typename std::list<value_type>::iterator iterator;
-
-  // The type of a const iterator over the hash map.
-  typedef typename std::list<value_type>::const_iterator const_iterator;
-
-  // Constructor.
-  hash_map()
-    : size_(0),
-      buckets_(0),
-      num_buckets_(0)
-  {
-  }
-
-  // Destructor.
-  ~hash_map()
-  {
-    delete[] buckets_;
-  }
-
-  // Get an iterator for the beginning of the map.
-  iterator begin()
-  {
-    return values_.begin();
-  }
-
-  // Get an iterator for the beginning of the map.
-  const_iterator begin() const
-  {
-    return values_.begin();
-  }
-
-  // Get an iterator for the end of the map.
-  iterator end()
-  {
-    return values_.end();
-  }
-
-  // Get an iterator for the end of the map.
-  const_iterator end() const
-  {
-    return values_.end();
-  }
-
-  // Check whether the map is empty.
-  bool empty() const
-  {
-    return values_.empty();
-  }
-
-  // Find an entry in the map.
-  iterator find(const K& k)
-  {
-    if (num_buckets_)
-    {
-      size_t bucket = calculate_hash_value(k) % num_buckets_;
-      iterator it = buckets_[bucket].first;
-      if (it == values_.end())
-        return values_.end();
-      iterator end = buckets_[bucket].last;
-      ++end;
-      while (it != end)
-      {
-        if (it->first == k)
-          return it;
-        ++it;
-      }
-    }
-    return values_.end();
-  }
-
-  // Find an entry in the map.
-  const_iterator find(const K& k) const
-  {
-    if (num_buckets_)
-    {
-      size_t bucket = calculate_hash_value(k) % num_buckets_;
-      const_iterator it = buckets_[bucket].first;
-      if (it == values_.end())
-        return it;
-      const_iterator end = buckets_[bucket].last;
-      ++end;
-      while (it != end)
-      {
-        if (it->first == k)
-          return it;
-        ++it;
-      }
-    }
-    return values_.end();
-  }
-
-  // Insert a new entry into the map.
-  std::pair<iterator, bool> insert(const value_type& v)
-  {
-    if (size_ + 1 >= num_buckets_)
-      rehash(hash_size(size_ + 1));
-    size_t bucket = calculate_hash_value(v.first) % num_buckets_;
-    iterator it = buckets_[bucket].first;
-    if (it == values_.end())
-    {
-      buckets_[bucket].first = buckets_[bucket].last =
-        values_insert(values_.end(), v);
-      ++size_;
-      return std::pair<iterator, bool>(buckets_[bucket].last, true);
-    }
-    iterator end = buckets_[bucket].last;
-    ++end;
-    while (it != end)
-    {
-      if (it->first == v.first)
-        return std::pair<iterator, bool>(it, false);
-      ++it;
-    }
-    buckets_[bucket].last = values_insert(end, v);
-    ++size_;
-    return std::pair<iterator, bool>(buckets_[bucket].last, true);
-  }
-
-  // Erase an entry from the map.
-  void erase(iterator it)
-  {
-    assert(it != values_.end());
-
-    size_t bucket = calculate_hash_value(it->first) % num_buckets_;
-    bool is_first = (it == buckets_[bucket].first);
-    bool is_last = (it == buckets_[bucket].last);
-    if (is_first && is_last)
-      buckets_[bucket].first = buckets_[bucket].last = values_.end();
-    else if (is_first)
-      ++buckets_[bucket].first;
-    else if (is_last)
-      --buckets_[bucket].last;
-
-    values_erase(it);
-    --size_;
-  }
-
-  // Erase a key from the map.
-  void erase(const K& k)
-  {
-    iterator it = find(k);
-    if (it != values_.end())
-      erase(it);
-  }
-
-  // Remove all entries from the map.
-  void clear()
-  {
-    // Clear the values.
-    values_.clear();
-    size_ = 0;
-
-    // Initialise all buckets to empty.
-    iterator end = values_.end();
-    for (size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end;
-  }
-
-private:
-  // Calculate the hash size for the specified number of elements.
-  static std::size_t hash_size(std::size_t num_elems)
-  {
-    static std::size_t sizes[] =
-    {
-#if defined(ASIO_HASH_MAP_BUCKETS)
-      ASIO_HASH_MAP_BUCKETS
-#else // ASIO_HASH_MAP_BUCKETS
-      3, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
-      49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
-      12582917, 25165843
-#endif // ASIO_HASH_MAP_BUCKETS
-    };
-    const std::size_t nth_size = sizeof(sizes) / sizeof(std::size_t) - 1;
-    for (std::size_t i = 0; i < nth_size; ++i)
-      if (num_elems < sizes[i])
-        return sizes[i];
-    return sizes[nth_size];
-  }
-
-  // Re-initialise the hash from the values already contained in the list.
-  void rehash(std::size_t num_buckets)
-  {
-    if (num_buckets == num_buckets_)
-      return;
-    num_buckets_ = num_buckets;
-
-    iterator end = values_.end();
-
-    // Update number of buckets and initialise all buckets to empty.
-    bucket_type* tmp = new bucket_type[num_buckets_];
-    delete[] buckets_;
-    buckets_ = tmp;
-    for (std::size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end;
-
-    // Put all values back into the hash.
-    iterator iter = values_.begin();
-    while (iter != end)
-    {
-      std::size_t bucket = calculate_hash_value(iter->first) % num_buckets_;
-      if (buckets_[bucket].last == end)
-      {
-        buckets_[bucket].first = buckets_[bucket].last = iter++;
-      }
-      else if (++buckets_[bucket].last == iter)
-      {
-        ++iter;
-      }
-      else
-      {
-        values_.splice(buckets_[bucket].last, values_, iter++);
-        --buckets_[bucket].last;
-      }
-    }
-  }
-
-  // Insert an element into the values list by splicing from the spares list,
-  // if a spare is available, and otherwise by inserting a new element.
-  iterator values_insert(iterator it, const value_type& v)
-  {
-    if (spares_.empty())
-    {
-      return values_.insert(it, v);
-    }
-    else
-    {
-      spares_.front() = v;
-      values_.splice(it, spares_, spares_.begin());
-      return --it;
-    }
-  }
-
-  // Erase an element from the values list by splicing it to the spares list.
-  void values_erase(iterator it)
-  {
-    *it = value_type();
-    spares_.splice(spares_.begin(), values_, it);
-  }
-
-  // The number of elements in the hash.
-  std::size_t size_;
-
-  // The list of all values in the hash map.
-  std::list<value_type> values_;
-
-  // The list of spare nodes waiting to be recycled. Assumes that POD types only
-  // are stored in the hash map.
-  std::list<value_type> spares_;
-
-  // The type for a bucket in the hash table.
-  struct bucket_type
-  {
-    iterator first;
-    iterator last;
-  };
-
-  // The buckets in the hash.
-  bucket_type* buckets_;
-
-  // The number of buckets in the hash.
-  std::size_t num_buckets_;
-};
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_HASH_MAP_HPP

ext/asio/asio/detail/impl/descriptor_ops.ipp

@@ -1,382 +0,0 @@
-//
-// detail/impl/descriptor_ops.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
-#define ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <cerrno>
-#include "asio/detail/descriptor_ops.hpp"
-#include "asio/error.hpp"
-
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-namespace descriptor_ops {
-
-ASIO_DECL
-int open(const char* path, int flags, asio::error_code& ec)
-{
-  errno = 0;
-  int result = error_wrapper(::open(path, flags), ec);
-  if (result >= 0)
-    ec = asio::error_code();
-  return result;
-}
-
-ASIO_DECL
-int close(int d, state_type& state, asio::error_code& ec)
-{
-  int result = 0;
-  if (d != -1)
-  {
-    if (state & internal_non_blocking)
-    {
-#if defined(__SYMBIAN32__)
-      int flags = ::fcntl(d, F_GETFL, 0);
-      if (flags >= 0)
-        ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
-#else // defined(__SYMBIAN32__)
-      ioctl_arg_type arg = 0;
-      ::ioctl(d, FIONBIO, &arg);
-#endif // defined(__SYMBIAN32__)
-      state &= ~internal_non_blocking;
-    }
-
-    errno = 0;
-    result = error_wrapper(::close(d), ec);
-  }
-
-  if (result == 0)
-    ec = asio::error_code();
-  return result;
-}
-
-ASIO_DECL
-bool set_internal_non_blocking(int d,
-    state_type& state, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return false;
-  }
-
-  errno = 0;
-#if defined(__SYMBIAN32__)
-  int result = error_wrapper(::fcntl(d, F_GETFL, 0), ec);
-  if (result >= 0)
-  {
-    errno = 0;
-    result = error_wrapper(::fcntl(d, F_SETFL, result | O_NONBLOCK), ec);
-  }
-#else // defined(__SYMBIAN32__)
-  ioctl_arg_type arg = 1;
-  int result = error_wrapper(::ioctl(d, FIONBIO, &arg), ec);
-#endif // defined(__SYMBIAN32__)
-
-  if (result >= 0)
-  {
-    ec = asio::error_code();
-    state |= internal_non_blocking;
-    return true;
-  }
-
-  return false;
-}
-
-ASIO_DECL
-std::size_t sync_read(int d, state_type state, buf* bufs,
-    std::size_t count, bool all_empty, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to read 0 bytes on a stream is a no-op.
-  if (all_empty)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    errno = 0;
-    int bytes = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Check for EOF.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return 0;
-    }
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_read(d, ec) < 0)
-      return 0;
-  }
-}
-
-ASIO_DECL
-bool non_blocking_read(int d, buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Read some data.
-    errno = 0;
-    int bytes = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec);
-
-    // Check for end of stream.
-    if (bytes == 0)
-    {
-      ec = asio::error::eof;
-      return true;
-    }
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation is complete.
-    if (bytes > 0)
-    {
-      ec = asio::error_code();
-      bytes_transferred = bytes;
-    }
-    else
-      bytes_transferred = 0;
-
-    return true;
-  }
-}
-
-ASIO_DECL
-std::size_t sync_write(int d, state_type state, const buf* bufs,
-    std::size_t count, bool all_empty, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes on a stream is a no-op.
-  if (all_empty)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  // Write some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    errno = 0;
-    int bytes = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec);
-
-    // Check if operation succeeded.
-    if (bytes > 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != asio::error::would_block
-          && ec != asio::error::try_again))
-      return 0;
-
-    // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_write(d, ec) < 0)
-      return 0;
-  }
-}
-
-ASIO_DECL
-bool non_blocking_write(int d, const buf* bufs, std::size_t count,
-    asio::error_code& ec, std::size_t& bytes_transferred)
-{
-  for (;;)
-  {
-    // Write some data.
-    errno = 0;
-    int bytes = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec);
-
-    // Retry operation if interrupted by signal.
-    if (ec == asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == asio::error::would_block
-        || ec == asio::error::try_again)
-      return false;
-
-    // Operation is complete.
-    if (bytes >= 0)
-    {
-      ec = asio::error_code();
-      bytes_transferred = bytes;
-    }
-    else
-      bytes_transferred = 0;
-
-    return true;
-  }
-}
-
-ASIO_DECL
-int ioctl(int d, state_type& state, long cmd,
-    ioctl_arg_type* arg, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  errno = 0;
-  int result = error_wrapper(::ioctl(d, cmd, arg), ec);
-
-  if (result >= 0)
-  {
-    ec = asio::error_code();
-
-    // When updating the non-blocking mode we always perform the ioctl syscall,
-    // even if the flags would otherwise indicate that the descriptor is
-    // already in the correct state. This ensures that the underlying
-    // descriptor is put into the state that has been requested by the user. If
-    // the ioctl syscall was successful then we need to update the flags to
-    // match.
-    if (cmd == static_cast<long>(FIONBIO))
-    {
-      if (*arg)
-      {
-        state |= user_set_non_blocking;
-      }
-      else
-      {
-        // Clearing the non-blocking mode always overrides any internally-set
-        // non-blocking flag. Any subsequent asynchronous operations will need
-        // to re-enable non-blocking I/O.
-        state &= ~(user_set_non_blocking | internal_non_blocking);
-      }
-    }
-  }
-
-  return result;
-}
-
-ASIO_DECL
-int fcntl(int d, long cmd, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  errno = 0;
-  int result = error_wrapper(::fcntl(d, cmd), ec);
-  if (result != -1)
-    ec = asio::error_code();
-  return result;
-}
-
-ASIO_DECL
-int fcntl(int d, long cmd, long arg, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  errno = 0;
-  int result = error_wrapper(::fcntl(d, cmd, arg), ec);
-  if (result != -1)
-    ec = asio::error_code();
-  return result;
-}
-
-ASIO_DECL
-int poll_read(int d, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  pollfd fds;
-  fds.fd = d;
-  fds.events = POLLIN;
-  fds.revents = 0;
-  errno = 0;
-  int result = error_wrapper(::poll(&fds, 1, -1), ec);
-  if (result >= 0)
-    ec = asio::error_code();
-  return result;
-}
-
-ASIO_DECL
-int poll_write(int d, asio::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = asio::error::bad_descriptor;
-    return -1;
-  }
-
-  pollfd fds;
-  fds.fd = d;
-  fds.events = POLLOUT;
-  fds.revents = 0;
-  errno = 0;
-  int result = error_wrapper(::poll(&fds, 1, -1), ec);
-  if (result >= 0)
-    ec = asio::error_code();
-  return result;
-}
-
-} // namespace descriptor_ops
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP

ext/asio/asio/detail/impl/dev_poll_reactor.hpp

@@ -1,77 +0,0 @@
-//
-// detail/impl/dev_poll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-void dev_poll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    io_service_.post_immediate_completion(op);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
-  if (earliest)
-    interrupter_.interrupt();
-}
-
-template <typename Time_Traits>
-std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
-  lock.unlock();
-  io_service_.post_deferred_completions(ops);
-  return n;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP

ext/asio/asio/detail/impl/dev_poll_reactor.ipp

@@ -1,338 +0,0 @@
-//
-// detail/impl/dev_poll_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_DEV_POLL)
-
-#include "asio/detail/dev_poll_reactor.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-dev_poll_reactor::dev_poll_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<dev_poll_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
-    mutex_(),
-    dev_poll_fd_(do_dev_poll_create()),
-    interrupter_(),
-    shutdown_(false)
-{
-  // Add the interrupter's descriptor to /dev/poll.
-  ::pollfd ev = { 0 };
-  ev.fd = interrupter_.read_descriptor();
-  ev.events = POLLIN | POLLERR;
-  ev.revents = 0;
-  ::write(dev_poll_fd_, &ev, sizeof(ev));
-}
-
-dev_poll_reactor::~dev_poll_reactor()
-{
-  shutdown_service();
-  ::close(dev_poll_fd_);
-}
-
-void dev_poll_reactor::shutdown_service()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].get_all_operations(ops);
-
-  timer_queues_.get_all_timers(ops);
-} 
-
-void dev_poll_reactor::init_task()
-{
-  io_service_.init_task();
-}
-
-int dev_poll_reactor::register_descriptor(socket_type, per_descriptor_data&)
-{
-  return 0;
-}
-
-void dev_poll_reactor::start_op(int op_type, socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&,
-    reactor_op* op, bool allow_speculative)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    post_immediate_completion(op);
-    return;
-  }
-
-  if (allow_speculative)
-  {
-    if (op_type != read_op || !op_queue_[except_op].has_operation(descriptor))
-    {
-      if (!op_queue_[op_type].has_operation(descriptor))
-      {
-        if (op->perform())
-        {
-          lock.unlock();
-          io_service_.post_immediate_completion(op);
-          return;
-        }
-      }
-    }
-  }
-
-  bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  io_service_.work_started();
-  if (first)
-  {
-    ::pollfd& ev = add_pending_event_change(descriptor);
-    ev.events = POLLERR | POLLHUP;
-    if (op_type == read_op
-        || op_queue_[read_op].has_operation(descriptor))
-      ev.events |= POLLIN;
-    if (op_type == write_op
-        || op_queue_[write_op].has_operation(descriptor))
-      ev.events |= POLLOUT;
-    if (op_type == except_op
-        || op_queue_[except_op].has_operation(descriptor))
-      ev.events |= POLLPRI;
-    interrupter_.interrupt();
-  }
-}
-
-void dev_poll_reactor::cancel_ops(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void dev_poll_reactor::close_descriptor(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Remove the descriptor from /dev/poll.
-  ::pollfd& ev = add_pending_event_change(descriptor);
-  ev.events = POLLREMOVE;
-  interrupter_.interrupt();
-
-  // Cancel any outstanding operations associated with the descriptor.
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // We can return immediately if there's no work to do and the reactor is
-  // not supposed to block.
-  if (!block && op_queue_[read_op].empty() && op_queue_[write_op].empty()
-      && op_queue_[except_op].empty() && timer_queues_.all_empty())
-    return;
-
-  // Write the pending event registration changes to the /dev/poll descriptor.
-  std::size_t events_size = sizeof(::pollfd) * pending_event_changes_.size();
-  if (events_size > 0)
-  {
-    errno = 0;
-    int result = ::write(dev_poll_fd_,
-        &pending_event_changes_[0], events_size);
-    if (result != static_cast<int>(events_size))
-    {
-      asio::error_code ec = asio::error_code(
-          errno, asio::error::get_system_category());
-      for (std::size_t i = 0; i < pending_event_changes_.size(); ++i)
-      {
-        int descriptor = pending_event_changes_[i].fd;
-        for (int j = 0; j < max_ops; ++j)
-          op_queue_[j].cancel_operations(descriptor, ops, ec);
-      }
-    }
-    pending_event_changes_.clear();
-    pending_event_change_index_.clear();
-  }
-
-  int timeout = block ? get_timeout() : 0;
-  lock.unlock();
-
-  // Block on the /dev/poll descriptor.
-  ::pollfd events[128] = { { 0 } };
-  ::dvpoll dp = { 0 };
-  dp.dp_fds = events;
-  dp.dp_nfds = 128;
-  dp.dp_timeout = timeout;
-  int num_events = ::ioctl(dev_poll_fd_, DP_POLL, &dp);
-
-  lock.lock();
-
-  // Dispatch the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    int descriptor = events[i].fd;
-    if (descriptor == interrupter_.read_descriptor())
-    {
-      interrupter_.reset();
-    }
-    else
-    {
-      bool more_reads = false;
-      bool more_writes = false;
-      bool more_except = false;
-
-      // Exception operations must be processed first to ensure that any
-      // out-of-band data is read before normal data.
-      if (events[i].events & (POLLPRI | POLLERR | POLLHUP))
-        more_except =
-          op_queue_[except_op].perform_operations(descriptor, ops);
-      else
-        more_except = op_queue_[except_op].has_operation(descriptor);
-
-      if (events[i].events & (POLLIN | POLLERR | POLLHUP))
-        more_reads = op_queue_[read_op].perform_operations(descriptor, ops);
-      else
-        more_reads = op_queue_[read_op].has_operation(descriptor);
-
-      if (events[i].events & (POLLOUT | POLLERR | POLLHUP))
-        more_writes = op_queue_[write_op].perform_operations(descriptor, ops);
-      else
-        more_writes = op_queue_[write_op].has_operation(descriptor);
-
-      if ((events[i].events & (POLLERR | POLLHUP)) != 0
-            && !more_except && !more_reads && !more_writes)
-      {
-        // If we have an event and no operations associated with the
-        // descriptor then we need to delete the descriptor from /dev/poll.
-        // The poll operation can produce POLLHUP or POLLERR events when there
-        // is no operation pending, so if we do not remove the descriptor we
-        // can end up in a tight polling loop.
-        ::pollfd ev = { 0 };
-        ev.fd = descriptor;
-        ev.events = POLLREMOVE;
-        ev.revents = 0;
-        ::write(dev_poll_fd_, &ev, sizeof(ev));
-      }
-      else
-      {
-        ::pollfd ev = { 0 };
-        ev.fd = descriptor;
-        ev.events = POLLERR | POLLHUP;
-        if (more_reads)
-          ev.events |= POLLIN;
-        if (more_writes)
-          ev.events |= POLLOUT;
-        if (more_except)
-          ev.events |= POLLPRI;
-        ev.revents = 0;
-        int result = ::write(dev_poll_fd_, &ev, sizeof(ev));
-        if (result != sizeof(ev))
-        {
-          asio::error_code ec(errno,
-              asio::error::get_system_category());
-          for (int j = 0; j < max_ops; ++j)
-            op_queue_[j].cancel_operations(descriptor, ops, ec);
-        }
-      }
-    }
-  }
-  timer_queues_.get_ready_timers(ops);
-}
-
-void dev_poll_reactor::interrupt()
-{
-  interrupter_.interrupt();
-}
-
-int dev_poll_reactor::do_dev_poll_create()
-{
-  int fd = ::open("/dev/poll", O_RDWR);
-  if (fd == -1)
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "/dev/poll");
-  }
-  return fd;
-}
-
-void dev_poll_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void dev_poll_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-int dev_poll_reactor::get_timeout()
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  return timer_queues_.wait_duration_msec(5 * 60 * 1000);
-}
-
-void dev_poll_reactor::cancel_ops_unlocked(socket_type descriptor,
-    const asio::error_code& ec)
-{
-  bool need_interrupt = false;
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    need_interrupt = op_queue_[i].cancel_operations(
-        descriptor, ops, ec) || need_interrupt;
-  io_service_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-
-::pollfd& dev_poll_reactor::add_pending_event_change(int descriptor)
-{
-  hash_map<int, std::size_t>::iterator iter
-    = pending_event_change_index_.find(descriptor);
-  if (iter == pending_event_change_index_.end())
-  {
-    std::size_t index = pending_event_changes_.size();
-    pending_event_changes_.reserve(pending_event_changes_.size() + 1);
-    pending_event_change_index_.insert(std::make_pair(descriptor, index));
-    pending_event_changes_.push_back(::pollfd());
-    pending_event_changes_[index].fd = descriptor;
-    pending_event_changes_[index].revents = 0;
-    return pending_event_changes_[index];
-  }
-  else
-  {
-    return pending_event_changes_[iter->second];
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_DEV_POLL)
-
-#endif // ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP

ext/asio/asio/detail/impl/epoll_reactor.hpp

@@ -1,75 +0,0 @@
-//
-// detail/impl/epoll_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    io_service_.post_immediate_completion(op);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
-  if (earliest)
-    update_timeout();
-}
-
-template <typename Time_Traits>
-std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
-  lock.unlock();
-  io_service_.post_deferred_completions(ops);
-  return n;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP

ext/asio/asio/detail/impl/epoll_reactor.ipp

@@ -1,390 +0,0 @@
-//
-// detail/impl/epoll_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include <cstddef>
-#include <sys/epoll.h>
-#include "asio/detail/epoll_reactor.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#if defined(ASIO_HAS_TIMERFD)
-# include <sys/timerfd.h>
-#endif // defined(ASIO_HAS_TIMERFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-epoll_reactor::epoll_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<epoll_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
-    mutex_(),
-    epoll_fd_(do_epoll_create()),
-#if defined(ASIO_HAS_TIMERFD)
-    timer_fd_(timerfd_create(CLOCK_MONOTONIC, 0)),
-#else // defined(ASIO_HAS_TIMERFD)
-    timer_fd_(-1),
-#endif // defined(ASIO_HAS_TIMERFD)
-    interrupter_(),
-    shutdown_(false)
-{
-  // Add the interrupter's descriptor to epoll.
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
-  ev.data.ptr = &interrupter_;
-  epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
-  interrupter_.interrupt();
-
-  // Add the timer descriptor to epoll.
-  if (timer_fd_ != -1)
-  {
-    ev.events = EPOLLIN | EPOLLERR;
-    ev.data.ptr = &timer_fd_;
-    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
-  }
-}
-
-epoll_reactor::~epoll_reactor()
-{
-  close(epoll_fd_);
-  if (timer_fd_ != -1)
-    close(timer_fd_);
-}
-
-void epoll_reactor::shutdown_service()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  while (descriptor_state* state = registered_descriptors_.first())
-  {
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(state->op_queue_[i]);
-    state->shutdown_ = true;
-    registered_descriptors_.free(state);
-  }
-
-  timer_queues_.get_all_timers(ops);
-}
-
-void epoll_reactor::init_task()
-{
-  io_service_.init_task();
-}
-
-int epoll_reactor::register_descriptor(socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  mutex::scoped_lock lock(registered_descriptors_mutex_);
-
-  descriptor_data = registered_descriptors_.alloc();
-  descriptor_data->shutdown_ = false;
-
-  lock.unlock();
-
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLOUT | EPOLLPRI | EPOLLET;
-  ev.data.ptr = descriptor_data;
-  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
-  if (result != 0)
-    return errno;
-
-  return 0;
-}
-
-void epoll_reactor::start_op(int op_type, socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data,
-    reactor_op* op, bool allow_speculative)
-{
-  if (!descriptor_data)
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    post_immediate_completion(op);
-    return;
-  }
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (descriptor_data->shutdown_)
-  {
-    post_immediate_completion(op);
-    return;
-  }
-
-  if (descriptor_data->op_queue_[op_type].empty())
-  {
-    if (allow_speculative
-        && (op_type != read_op
-          || descriptor_data->op_queue_[except_op].empty()))
-    {
-      if (op->perform())
-      {
-        descriptor_lock.unlock();
-        io_service_.post_immediate_completion(op);
-        return;
-      }
-    }
-    else
-    {
-      epoll_event ev = { 0, { 0 } };
-      ev.events = EPOLLIN | EPOLLERR | EPOLLHUP
-        | EPOLLOUT | EPOLLPRI | EPOLLET;
-      ev.data.ptr = descriptor_data;
-      epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
-    }
-  }
-
-  descriptor_data->op_queue_[op_type].push(op);
-  io_service_.work_started();
-}
-
-void epoll_reactor::cancel_ops(socket_type,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-  {
-    while (reactor_op* op = descriptor_data->op_queue_[i].front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      descriptor_data->op_queue_[i].pop();
-      ops.push(op);
-    }
-  }
-
-  descriptor_lock.unlock();
-
-  io_service_.post_deferred_completions(ops);
-}
-
-void epoll_reactor::close_descriptor(socket_type,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    // Remove the descriptor from the set of known descriptors. The descriptor
-    // will be automatically removed from the epoll set when it is closed.
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-    {
-      while (reactor_op* op = descriptor_data->op_queue_[i].front())
-      {
-        op->ec_ = asio::error::operation_aborted;
-        descriptor_data->op_queue_[i].pop();
-        ops.push(op);
-      }
-    }
-
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    registered_descriptors_.free(descriptor_data);
-    descriptor_data = 0;
-
-    descriptors_lock.unlock();
-
-    io_service_.post_deferred_completions(ops);
-  }
-}
-
-void epoll_reactor::run(bool block, op_queue<operation>& ops)
-{
-  // Calculate a timeout only if timerfd is not used.
-  int timeout;
-  if (timer_fd_ != -1)
-    timeout = block ? -1 : 0;
-  else
-  {
-    mutex::scoped_lock lock(mutex_);
-    timeout = block ? get_timeout() : 0;
-  }
-
-  // Block on the epoll descriptor.
-  epoll_event events[128];
-  int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
-
-#if defined(ASIO_HAS_TIMERFD)
-  bool check_timers = (timer_fd_ == -1);
-#else // defined(ASIO_HAS_TIMERFD)
-  bool check_timers = true;
-#endif // defined(ASIO_HAS_TIMERFD)
-
-  // Dispatch the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    void* ptr = events[i].data.ptr;
-    if (ptr == &interrupter_)
-    {
-      // No need to reset the interrupter since we're leaving the descriptor
-      // in a ready-to-read state and relying on edge-triggered notifications
-      // to make it so that we only get woken up when the descriptor's epoll
-      // registration is updated.
-
-#if defined(ASIO_HAS_TIMERFD)
-      if (timer_fd_ == -1)
-        check_timers = true;
-#else // defined(ASIO_HAS_TIMERFD)
-      check_timers = true;
-#endif // defined(ASIO_HAS_TIMERFD)
-    }
-#if defined(ASIO_HAS_TIMERFD)
-    else if (ptr == &timer_fd_)
-    {
-      check_timers = true;
-    }
-#endif // defined(ASIO_HAS_TIMERFD)
-    else
-    {
-      descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
-      mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-      // Exception operations must be processed first to ensure that any
-      // out-of-band data is read before normal data.
-      static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
-      for (int j = max_ops - 1; j >= 0; --j)
-      {
-        if (events[i].events & (flag[j] | EPOLLERR | EPOLLHUP))
-        {
-          while (reactor_op* op = descriptor_data->op_queue_[j].front())
-          {
-            if (op->perform())
-            {
-              descriptor_data->op_queue_[j].pop();
-              ops.push(op);
-            }
-            else
-              break;
-          }
-        }
-      }
-    }
-  }
-
-  if (check_timers)
-  {
-    mutex::scoped_lock common_lock(mutex_);
-    timer_queues_.get_ready_timers(ops);
-
-#if defined(ASIO_HAS_TIMERFD)
-    if (timer_fd_ != -1)
-    {
-      itimerspec new_timeout;
-      itimerspec old_timeout;
-      int flags = get_timeout(new_timeout);
-      timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
-    }
-#endif // defined(ASIO_HAS_TIMERFD)
-  }
-}
-
-void epoll_reactor::interrupt()
-{
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
-  ev.data.ptr = &interrupter_;
-  epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, interrupter_.read_descriptor(), &ev);
-}
-
-int epoll_reactor::do_epoll_create()
-{
-  int fd = epoll_create(epoll_size);
-  if (fd == -1)
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "epoll");
-  }
-  return fd;
-}
-
-void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-void epoll_reactor::update_timeout()
-{
-#if defined(ASIO_HAS_TIMERFD)
-  if (timer_fd_ != -1)
-  {
-    itimerspec new_timeout;
-    itimerspec old_timeout;
-    int flags = get_timeout(new_timeout);
-    timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
-    return;
-  }
-#endif // defined(ASIO_HAS_TIMERFD)
-  interrupt();
-}
-
-int epoll_reactor::get_timeout()
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  return timer_queues_.wait_duration_msec(5 * 60 * 1000);
-}
-
-#if defined(ASIO_HAS_TIMERFD)
-int epoll_reactor::get_timeout(itimerspec& ts)
-{
-  ts.it_interval.tv_sec = 0;
-  ts.it_interval.tv_nsec = 0;
-
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
-  ts.it_value.tv_sec = usec / 1000000;
-  ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
-
-  return usec ? 0 : TFD_TIMER_ABSTIME;
-}
-#endif // defined(ASIO_HAS_TIMERFD)
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP

ext/asio/asio/detail/impl/eventfd_select_interrupter.ipp

@@ -1,125 +0,0 @@
-//
-// detail/impl/eventfd_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
-#define ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EVENTFD)
-
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-# include <asm/unistd.h>
-#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-# include <sys/eventfd.h>
-#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-#include "asio/detail/eventfd_select_interrupter.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-eventfd_select_interrupter::eventfd_select_interrupter()
-{
-#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-  write_descriptor_ = read_descriptor_ = syscall(__NR_eventfd, 0);
-#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-  write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
-#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-  if (read_descriptor_ != -1)
-  {
-    ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-  }
-  else
-  {
-    int pipe_fds[2];
-    if (pipe(pipe_fds) == 0)
-    {
-      read_descriptor_ = pipe_fds[0];
-      ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-      write_descriptor_ = pipe_fds[1];
-      ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
-    }
-    else
-    {
-      asio::error_code ec(errno,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "eventfd_select_interrupter");
-    }
-  }
-}
-
-eventfd_select_interrupter::~eventfd_select_interrupter()
-{
-  if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
-    ::close(write_descriptor_);
-  if (read_descriptor_ != -1)
-    ::close(read_descriptor_);
-}
-
-void eventfd_select_interrupter::interrupt()
-{
-  uint64_t counter(1UL);
-  int result = ::write(write_descriptor_, &counter, sizeof(uint64_t));
-  (void)result;
-}
-
-bool eventfd_select_interrupter::reset()
-{
-  if (write_descriptor_ == read_descriptor_)
-  {
-    for (;;)
-    {
-      // Only perform one read. The kernel maintains an atomic counter.
-      uint64_t counter(0);
-      errno = 0;
-      int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
-      if (bytes_read < 0 && errno == EINTR)
-        continue;
-      bool was_interrupted = (bytes_read > 0);
-      return was_interrupted;
-    }
-  }
-  else
-  {
-    for (;;)
-    {
-      // Clear all data from the pipe.
-      char data[1024];
-      int bytes_read = ::read(read_descriptor_, data, sizeof(data));
-      if (bytes_read < 0 && errno == EINTR)
-        continue;
-      bool was_interrupted = (bytes_read > 0);
-      while (bytes_read == sizeof(data))
-        bytes_read = ::read(read_descriptor_, data, sizeof(data));
-      return was_interrupted;
-    }
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EVENTFD)
-
-#endif // ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP

ext/asio/asio/detail/impl/kqueue_reactor.hpp

@@ -1,79 +0,0 @@
-//
-// detail/impl/kqueue_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_KQUEUE)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-void kqueue_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-// Remove a timer queue from the reactor.
-template <typename Time_Traits>
-void kqueue_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    io_service_.post_immediate_completion(op);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
-  if (earliest)
-    interrupt();
-}
-
-template <typename Time_Traits>
-std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
-  lock.unlock();
-  io_service_.post_deferred_completions(ops);
-  return n;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_KQUEUE)
-
-#endif // ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP

ext/asio/asio/detail/impl/kqueue_reactor.ipp

@@ -1,387 +0,0 @@
-//
-// detail/impl/kqueue_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_KQUEUE)
-
-#include "asio/detail/kqueue_reactor.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-#if defined(__NetBSD__)
-# define ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
-    EV_SET(ev, ident, filt, flags, fflags, \
-      data, reinterpret_cast<intptr_t>(udata))
-#else
-# define ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
-    EV_SET(ev, ident, filt, flags, fflags, data, udata)
-#endif
-
-namespace asio {
-namespace detail {
-
-kqueue_reactor::kqueue_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<kqueue_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
-    mutex_(),
-    kqueue_fd_(do_kqueue_create()),
-    interrupter_(),
-    shutdown_(false)
-{
-  // The interrupter is put into a permanently readable state. Whenever we
-  // want to interrupt the blocked kevent call we register a one-shot read
-  // operation against the descriptor.
-  interrupter_.interrupt();
-}
-
-kqueue_reactor::~kqueue_reactor()
-{
-  close(kqueue_fd_);
-}
-
-void kqueue_reactor::shutdown_service()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  op_queue<operation> ops;
-
-  while (descriptor_state* state = registered_descriptors_.first())
-  {
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(state->op_queue_[i]);
-    state->shutdown_ = true;
-    registered_descriptors_.free(state);
-  }
-
-  timer_queues_.get_all_timers(ops);
-}
-
-void kqueue_reactor::init_task()
-{
-  io_service_.init_task();
-}
-
-int kqueue_reactor::register_descriptor(socket_type,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  mutex::scoped_lock lock(registered_descriptors_mutex_);
-
-  descriptor_data = registered_descriptors_.alloc();
-  descriptor_data->shutdown_ = false;
-
-  return 0;
-}
-
-void kqueue_reactor::start_op(int op_type, socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data,
-    reactor_op* op, bool allow_speculative)
-{
-  if (!descriptor_data)
-  {
-    op->ec_ = asio::error::bad_descriptor;
-    post_immediate_completion(op);
-    return;
-  }
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (descriptor_data->shutdown_)
-  {
-    post_immediate_completion(op);
-    return;
-  }
-
-  bool first = descriptor_data->op_queue_[op_type].empty();
-  if (first)
-  {
-    if (allow_speculative)
-    {
-      if (op_type != read_op || descriptor_data->op_queue_[except_op].empty())
-      {
-        if (op->perform())
-        {
-          descriptor_lock.unlock();
-          io_service_.post_immediate_completion(op);
-          return;
-        }
-      }
-    }
-  }
-
-  descriptor_data->op_queue_[op_type].push(op);
-  io_service_.work_started();
-
-  if (first)
-  {
-    struct kevent event;
-    switch (op_type)
-    {
-    case read_op:
-      ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-          EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
-      break;
-    case write_op:
-      ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
-          EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
-      break;
-    case except_op:
-      if (!descriptor_data->op_queue_[read_op].empty())
-        return; // Already registered for read events.
-      ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-          EV_ADD | EV_ONESHOT, EV_OOBAND, 0, descriptor_data);
-      break;
-    }
-
-    if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
-    {
-      op->ec_ = asio::error_code(errno,
-          asio::error::get_system_category());
-      descriptor_data->op_queue_[op_type].pop();
-      io_service_.post_deferred_completion(op);
-    }
-  }
-}
-
-void kqueue_reactor::cancel_ops(socket_type,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-  {
-    while (reactor_op* op = descriptor_data->op_queue_[i].front())
-    {
-      op->ec_ = asio::error::operation_aborted;
-      descriptor_data->op_queue_[i].pop();
-      ops.push(op);
-    }
-  }
-
-  descriptor_lock.unlock();
-
-  io_service_.post_deferred_completions(ops);
-}
-
-void kqueue_reactor::close_descriptor(socket_type,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    // Remove the descriptor from the set of known descriptors. The descriptor
-    // will be automatically removed from the kqueue set when it is closed.
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-    {
-      while (reactor_op* op = descriptor_data->op_queue_[i].front())
-      {
-        op->ec_ = asio::error::operation_aborted;
-        descriptor_data->op_queue_[i].pop();
-        ops.push(op);
-      }
-    }
-
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    registered_descriptors_.free(descriptor_data);
-    descriptor_data = 0;
-
-    descriptors_lock.unlock();
-
-    io_service_.post_deferred_completions(ops);
-  }
-}
-
-void kqueue_reactor::run(bool block, op_queue<operation>& ops)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Determine how long to block while waiting for events.
-  timespec timeout_buf = { 0, 0 };
-  timespec* timeout = block ? get_timeout(timeout_buf) : &timeout_buf;
-
-  lock.unlock();
-
-  // Block on the kqueue descriptor.
-  struct kevent events[128];
-  int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout);
-
-  // Dispatch the waiting events.
-  for (int i = 0; i < num_events; ++i)
-  {
-    int descriptor = events[i].ident;
-    void* ptr = reinterpret_cast<void*>(events[i].udata);
-    if (ptr == &interrupter_)
-    {
-      // No need to reset the interrupter since we're leaving the descriptor
-      // in a ready-to-read state and relying on one-shot notifications.
-    }
-    else
-    {
-      descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
-      mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-      // Exception operations must be processed first to ensure that any
-      // out-of-band data is read before normal data.
-#if defined(__NetBSD__)
-      static const unsigned int filter[max_ops] =
-#else
-      static const int filter[max_ops] =
-#endif
-        { EVFILT_READ, EVFILT_WRITE, EVFILT_READ };
-      for (int j = max_ops - 1; j >= 0; --j)
-      {
-        if (events[i].filter == filter[j])
-        {
-          if (j != except_op || events[i].flags & EV_OOBAND)
-          {
-            while (reactor_op* op = descriptor_data->op_queue_[j].front())
-            {
-              if (events[i].flags & EV_ERROR)
-              {
-                op->ec_ = asio::error_code(events[i].data,
-                    asio::error::get_system_category());
-                descriptor_data->op_queue_[j].pop();
-                ops.push(op);
-              }
-              if (op->perform())
-              {
-                descriptor_data->op_queue_[j].pop();
-                ops.push(op);
-              }
-              else
-                break;
-            }
-          }
-        }
-      }
-
-      // Renew registration for event notifications.
-      struct kevent event;
-      switch (events[i].filter)
-      {
-      case EVFILT_READ:
-        if (!descriptor_data->op_queue_[read_op].empty())
-          ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-              EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
-        else if (!descriptor_data->op_queue_[except_op].empty())
-          ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-              EV_ADD | EV_ONESHOT, EV_OOBAND, 0, descriptor_data);
-        else
-          continue;
-        break;
-      case EVFILT_WRITE:
-        if (!descriptor_data->op_queue_[write_op].empty())
-          ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
-              EV_ADD | EV_ONESHOT, 0, 0, descriptor_data);
-        else
-          continue;
-        break;
-      default:
-        break;
-      }
-      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
-      {
-        asio::error_code error(errno,
-            asio::error::get_system_category());
-        for (int j = 0; j < max_ops; ++j)
-        {
-          while (reactor_op* op = descriptor_data->op_queue_[j].front())
-          {
-            op->ec_ = error;
-            descriptor_data->op_queue_[j].pop();
-            ops.push(op);
-          }
-        }
-      }
-    }
-  }
-
-  lock.lock();
-  timer_queues_.get_ready_timers(ops);
-}
-
-void kqueue_reactor::interrupt()
-{
-  struct kevent event;
-  ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(),
-      EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, &interrupter_);
-  ::kevent(kqueue_fd_, &event, 1, 0, 0, 0);
-}
-
-int kqueue_reactor::do_kqueue_create()
-{
-  int fd = ::kqueue();
-  if (fd == -1)
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "kqueue");
-  }
-  return fd;
-}
-
-void kqueue_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void kqueue_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-timespec* kqueue_reactor::get_timeout(timespec& ts)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
-  ts.tv_sec = usec / 1000000;
-  ts.tv_nsec = (usec % 1000000) * 1000;
-  return &ts;
-}
-
-} // namespace detail
-} // namespace asio
-
-#undef ASIO_KQUEUE_EV_SET
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_KQUEUE)
-
-#endif // ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP

ext/asio/asio/detail/impl/pipe_select_interrupter.ipp

@@ -1,96 +0,0 @@
-//
-// detail/impl/pipe_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
-#define ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_WINDOWS)
-#if !defined(__CYGWIN__)
-#if !defined(__SYMBIAN32__)
-#if !defined(ASIO_HAS_EVENTFD)
-
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include "asio/detail/pipe_select_interrupter.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-pipe_select_interrupter::pipe_select_interrupter()
-{
-  int pipe_fds[2];
-  if (pipe(pipe_fds) == 0)
-  {
-    read_descriptor_ = pipe_fds[0];
-    ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-    write_descriptor_ = pipe_fds[1];
-    ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
-  }
-  else
-  {
-    asio::error_code ec(errno,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "pipe_select_interrupter");
-  }
-}
-
-pipe_select_interrupter::~pipe_select_interrupter()
-{
-  if (read_descriptor_ != -1)
-    ::close(read_descriptor_);
-  if (write_descriptor_ != -1)
-    ::close(write_descriptor_);
-}
-
-void pipe_select_interrupter::interrupt()
-{
-  char byte = 0;
-  int result = ::write(write_descriptor_, &byte, 1);
-  (void)result;
-}
-
-bool pipe_select_interrupter::reset()
-{
-  for (;;)
-  {
-    char data[1024];
-    int bytes_read = ::read(read_descriptor_, data, sizeof(data));
-    if (bytes_read < 0 && errno == EINTR)
-      continue;
-    bool was_interrupted = (bytes_read > 0);
-    while (bytes_read == sizeof(data))
-      bytes_read = ::read(read_descriptor_, data, sizeof(data));
-    return was_interrupted;
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_EVENTFD)
-#endif // !defined(__SYMBIAN32__)
-#endif // !defined(__CYGWIN__)
-#endif // !defined(BOOST_WINDOWS)
-
-#endif // ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP

ext/asio/asio/detail/impl/posix_event.ipp

@@ -1,46 +0,0 @@
-//
-// detail/impl/posix_event.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
-#define ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#include "asio/detail/posix_event.hpp"
-#include "asio/detail/throw_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_event::posix_event()
-  : signalled_(false)
-{
-  int error = ::pthread_cond_init(&cond_, 0);
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "event");
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_EVENT_IPP

ext/asio/asio/detail/impl/posix_mutex.ipp

@@ -1,46 +0,0 @@
-//
-// detail/impl/posix_mutex.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
-#define ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#include "asio/detail/posix_mutex.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_mutex::posix_mutex()
-{
-  int error = ::pthread_mutex_init(&mutex_, 0);
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "mutex");
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP

ext/asio/asio/detail/impl/posix_thread.ipp

@@ -1,74 +0,0 @@
-//
-// detail/impl/posix_thread.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
-#define ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#include "asio/detail/posix_thread.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-posix_thread::~posix_thread()
-{
-  if (!joined_)
-    ::pthread_detach(thread_);
-}
-
-void posix_thread::join()
-{
-  if (!joined_)
-  {
-    ::pthread_join(thread_, 0);
-    joined_ = true;
-  }
-}
-
-void posix_thread::start_thread(func_base* arg)
-{
-  int error = ::pthread_create(&thread_, 0,
-        asio_detail_posix_thread_function, arg);
-  if (error != 0)
-  {
-    delete arg;
-    asio::error_code ec(error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "thread");
-  }
-}
-
-void* asio_detail_posix_thread_function(void* arg)
-{
-  posix_thread::auto_func_base_ptr func = {
-      static_cast<posix_thread::func_base*>(arg) };
-  func.ptr->run();
-  return 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_THREAD_IPP

ext/asio/asio/detail/impl/posix_tss_ptr.ipp

@@ -1,46 +0,0 @@
-//
-// detail/impl/posix_tss_ptr.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
-#define ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#include "asio/detail/posix_tss_ptr.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-void posix_tss_ptr_create(pthread_key_t& key)
-{
-  int error = ::pthread_key_create(&key, 0);
-  asio::error_code ec(error,
-      asio::error::get_system_category());
-  asio::detail::throw_error(ec, "tss");
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(ASIO_DISABLE_THREADS)
-
-#endif // ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP

ext/asio/asio/detail/impl/reactive_descriptor_service.ipp

@@ -1,136 +0,0 @@
-//
-// detail/impl/reactive_descriptor_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include "asio/error.hpp"
-#include "asio/detail/reactive_descriptor_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-reactive_descriptor_service::reactive_descriptor_service(
-    asio::io_service& io_service)
-  : reactor_(asio::use_service<reactor>(io_service))
-{
-  reactor_.init_task();
-}
-
-void reactive_descriptor_service::shutdown_service()
-{
-}
-
-void reactive_descriptor_service::construct(
-    reactive_descriptor_service::implementation_type& impl)
-{
-  impl.descriptor_ = -1;
-  impl.state_ = 0;
-}
-
-void reactive_descriptor_service::destroy(
-    reactive_descriptor_service::implementation_type& impl)
-{
-  if (is_open(impl))
-    reactor_.close_descriptor(impl.descriptor_, impl.reactor_data_);
-
-  asio::error_code ignored_ec;
-  descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
-}
-
-asio::error_code reactive_descriptor_service::assign(
-    reactive_descriptor_service::implementation_type& impl,
-    const native_type& native_descriptor, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  if (int err = reactor_.register_descriptor(
-        native_descriptor, impl.reactor_data_))
-  {
-    ec = asio::error_code(err,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  impl.descriptor_ = native_descriptor;
-  impl.state_ = 0;
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code reactive_descriptor_service::close(
-    reactive_descriptor_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-    reactor_.close_descriptor(impl.descriptor_, impl.reactor_data_);
-
-  if (descriptor_ops::close(impl.descriptor_, impl.state_, ec) == 0)
-    construct(impl);
-
-  return ec;
-}
-
-asio::error_code reactive_descriptor_service::cancel(
-    reactive_descriptor_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
-  ec = asio::error_code();
-  return ec;
-}
-
-void reactive_descriptor_service::start_op(
-    reactive_descriptor_service::implementation_type& impl,
-    int op_type, reactor_op* op, bool non_blocking, bool noop)
-{
-  if (!noop)
-  {
-    if ((impl.state_ & descriptor_ops::non_blocking) ||
-        descriptor_ops::set_internal_non_blocking(
-          impl.descriptor_, impl.state_, op->ec_))
-    {
-      reactor_.start_op(op_type, impl.descriptor_,
-          impl.reactor_data_, op, non_blocking);
-      return;
-    }
-  }
-
-  reactor_.post_immediate_completion(op);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#endif // ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP

ext/asio/asio/detail/impl/reactive_serial_port_service.ipp

@@ -1,151 +0,0 @@
-//
-// detail/impl/reactive_serial_port_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_SERIAL_PORT)
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include <cstring>
-#include "asio/detail/reactive_serial_port_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-reactive_serial_port_service::reactive_serial_port_service(
-    asio::io_service& io_service)
-  : descriptor_service_(io_service)
-{
-}
-
-void reactive_serial_port_service::shutdown_service()
-{
-  descriptor_service_.shutdown_service();
-}
-
-asio::error_code reactive_serial_port_service::open(
-    reactive_serial_port_service::implementation_type& impl,
-    const std::string& device, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  descriptor_ops::state_type state = 0;
-  int fd = descriptor_ops::open(device.c_str(),
-      O_RDWR | O_NONBLOCK | O_NOCTTY, ec);
-  if (fd < 0)
-    return ec;
-
-  int s = descriptor_ops::fcntl(fd, F_GETFL, ec);
-  if (s >= 0)
-    s = descriptor_ops::fcntl(fd, F_SETFL, s | O_NONBLOCK, ec);
-  if (s < 0)
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-    return ec;
-  }
-
-  // Set up default serial port options.
-  termios ios;
-  errno = 0;
-  s = descriptor_ops::error_wrapper(::tcgetattr(fd, &ios), ec);
-  if (s >= 0)
-  {
-#if defined(_BSD_SOURCE)
-    ::cfmakeraw(&ios);
-#else
-    ios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK
-        | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
-    ios.c_oflag &= ~OPOST;
-    ios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
-    ios.c_cflag &= ~(CSIZE | PARENB);
-    ios.c_cflag |= CS8;
-#endif
-    ios.c_iflag |= IGNPAR;
-    ios.c_cflag |= CREAD | CLOCAL;
-    errno = 0;
-    s = descriptor_ops::error_wrapper(::tcsetattr(fd, TCSANOW, &ios), ec);
-  }
-  if (s < 0)
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-    return ec;
-  }
-
-  // We're done. Take ownership of the serial port descriptor.
-  if (descriptor_service_.assign(impl, fd, ec))
-  {
-    asio::error_code ignored_ec;
-    descriptor_ops::close(fd, state, ignored_ec);
-  }
-
-  return ec;
-}
-
-asio::error_code reactive_serial_port_service::do_set_option(
-    reactive_serial_port_service::implementation_type& impl,
-    reactive_serial_port_service::store_function_type store,
-    const void* option, asio::error_code& ec)
-{
-  termios ios;
-  errno = 0;
-  descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native(impl), &ios), ec);
-  if (ec)
-    return ec;
-
-  if (store(option, ios, ec))
-    return ec;
-
-  errno = 0;
-  descriptor_ops::error_wrapper(::tcsetattr(
-        descriptor_service_.native(impl), TCSANOW, &ios), ec);
-  return ec;
-}
-
-asio::error_code reactive_serial_port_service::do_get_option(
-    const reactive_serial_port_service::implementation_type& impl,
-    reactive_serial_port_service::load_function_type load,
-    void* option, asio::error_code& ec) const
-{
-  termios ios;
-  errno = 0;
-  descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native(impl), &ios), ec);
-  if (ec)
-    return ec;
-
-  return load(option, ios, ec);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#endif // defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP

ext/asio/asio/detail/impl/reactive_socket_service_base.ipp

@@ -1,212 +0,0 @@
-//
-// detail/reactive_socket_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/reactive_socket_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-reactive_socket_service_base::reactive_socket_service_base(
-    asio::io_service& io_service)
-  : reactor_(use_service<reactor>(io_service))
-{
-  reactor_.init_task();
-}
-
-void reactive_socket_service_base::shutdown_service()
-{
-}
-
-void reactive_socket_service_base::construct(
-    reactive_socket_service_base::base_implementation_type& impl)
-{
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-}
-
-void reactive_socket_service_base::destroy(
-    reactive_socket_service_base::base_implementation_type& impl)
-{
-  if (impl.socket_ != invalid_socket)
-  {
-    reactor_.close_descriptor(impl.socket_, impl.reactor_data_);
-
-    asio::error_code ignored_ec;
-    socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
-  }
-}
-
-asio::error_code reactive_socket_service_base::close(
-    reactive_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-    reactor_.close_descriptor(impl.socket_, impl.reactor_data_);
-
-  if (socket_ops::close(impl.socket_, impl.state_, true, ec) == 0)
-    construct(impl);
-
-  return ec;
-}
-
-asio::error_code reactive_socket_service_base::cancel(
-    reactive_socket_service_base::base_implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return ec;
-  }
-
-  reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code reactive_socket_service_base::do_open(
-    reactive_socket_service_base::base_implementation_type& impl,
-    int af, int type, int protocol, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  socket_holder sock(socket_ops::socket(af, type, protocol, ec));
-  if (sock.get() == invalid_socket)
-    return ec;
-
-  if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_))
-  {
-    ec = asio::error_code(err,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  impl.socket_ = sock.release();
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code reactive_socket_service_base::do_assign(
-    reactive_socket_service_base::base_implementation_type& impl, int type,
-    const reactive_socket_service_base::native_type& native_socket,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  if (int err = reactor_.register_descriptor(
-        native_socket, impl.reactor_data_))
-  {
-    ec = asio::error_code(err,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  impl.socket_ = native_socket;
-  switch (type)
-  {
-  case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
-  case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
-  default: impl.state_ = 0; break;
-  }
-  ec = asio::error_code();
-  return ec;
-}
-
-void reactive_socket_service_base::start_op(
-    reactive_socket_service_base::base_implementation_type& impl,
-    int op_type, reactor_op* op, bool non_blocking, bool noop)
-{
-  if (!noop)
-  {
-    if ((impl.state_ & socket_ops::non_blocking)
-        || socket_ops::set_internal_non_blocking(
-          impl.socket_, impl.state_, op->ec_))
-    {
-      reactor_.start_op(op_type, impl.socket_,
-          impl.reactor_data_, op, non_blocking);
-      return;
-    }
-  }
-
-  reactor_.post_immediate_completion(op);
-}
-
-void reactive_socket_service_base::start_accept_op(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, bool peer_is_open)
-{
-  if (!peer_is_open)
-    start_op(impl, reactor::read_op, op, true, false);
-  else
-  {
-    op->ec_ = asio::error::already_open;
-    reactor_.post_immediate_completion(op);
-  }
-}
-
-void reactive_socket_service_base::start_connect_op(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, const socket_addr_type* addr, size_t addrlen)
-{
-  if ((impl.state_ & socket_ops::non_blocking)
-      || socket_ops::set_internal_non_blocking(
-        impl.socket_, impl.state_, op->ec_))
-  {
-    if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
-    {
-      if (op->ec_ == asio::error::in_progress
-          || op->ec_ == asio::error::would_block)
-      {
-        op->ec_ = asio::error_code();
-        reactor_.start_op(reactor::connect_op,
-            impl.socket_, impl.reactor_data_, op, false);
-        return;
-      }
-    }
-  }
-
-  reactor_.post_immediate_completion(op);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP

ext/asio/asio/detail/impl/resolver_service_base.ipp

@@ -1,106 +0,0 @@
-//
-// detail/impl/resolver_service_base.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
-#define ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/resolver_service_base.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class resolver_service_base::work_io_service_runner
-{
-public:
-  work_io_service_runner(asio::io_service& io_service)
-    : io_service_(io_service) {}
-  void operator()() { io_service_.run(); }
-private:
-  asio::io_service& io_service_;
-};
-
-resolver_service_base::resolver_service_base(
-    asio::io_service& io_service)
-  : io_service_impl_(asio::use_service<io_service_impl>(io_service)),
-    work_io_service_(new asio::io_service),
-    work_io_service_impl_(asio::use_service<
-        io_service_impl>(*work_io_service_)),
-    work_(new asio::io_service::work(*work_io_service_)),
-    work_thread_(0)
-{
-}
-
-resolver_service_base::~resolver_service_base()
-{
-  shutdown_service();
-}
-
-void resolver_service_base::shutdown_service()
-{
-  work_.reset();
-  if (work_io_service_)
-  {
-    work_io_service_->stop();
-    if (work_thread_)
-    {
-      work_thread_->join();
-      work_thread_.reset();
-    }
-    work_io_service_.reset();
-  }
-}
-
-void resolver_service_base::construct(
-    resolver_service_base::implementation_type& impl)
-{
-  impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
-}
-
-void resolver_service_base::destroy(
-    resolver_service_base::implementation_type&)
-{
-}
-
-void resolver_service_base::cancel(
-    resolver_service_base::implementation_type& impl)
-{
-  impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
-}
-
-void resolver_service_base::start_resolve_op(operation* op)
-{
-  start_work_thread();
-  io_service_impl_.work_started();
-  work_io_service_impl_.post_immediate_completion(op);
-}
-
-void resolver_service_base::start_work_thread()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!work_thread_)
-  {
-    work_thread_.reset(new asio::detail::thread(
-          work_io_service_runner(*work_io_service_)));
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP

ext/asio/asio/detail/impl/select_reactor.hpp

@@ -1,84 +0,0 @@
-//
-// detail/impl/select_reactor.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
-#define ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) \
-  || (!defined(ASIO_HAS_DEV_POLL) \
-      && !defined(ASIO_HAS_EPOLL) \
-      && !defined(ASIO_HAS_KQUEUE))
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-void select_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-// Remove a timer queue from the reactor.
-template <typename Time_Traits>
-void select_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    io_service_.post_immediate_completion(op);
-    return;
-  }
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  io_service_.work_started();
-  if (earliest)
-    interrupter_.interrupt();
-}
-
-template <typename Time_Traits>
-std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
-  lock.unlock();
-  io_service_.post_deferred_completions(ops);
-  return n;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-       //   || (!defined(ASIO_HAS_DEV_POLL)
-       //       && !defined(ASIO_HAS_EPOLL)
-       //       && !defined(ASIO_HAS_KQUEUE))
-
-#endif // ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP

ext/asio/asio/detail/impl/select_reactor.ipp

@@ -1,273 +0,0 @@
-//
-// detail/impl/select_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) \
-  || (!defined(ASIO_HAS_DEV_POLL) \
-      && !defined(ASIO_HAS_EPOLL) \
-      && !defined(ASIO_HAS_KQUEUE))
-
-#include "asio/detail/bind_handler.hpp"
-#include "asio/detail/fd_set_adapter.hpp"
-#include "asio/detail/select_reactor.hpp"
-#include "asio/detail/signal_blocker.hpp"
-#include "asio/detail/socket_ops.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-select_reactor::select_reactor(asio::io_service& io_service)
-  : asio::detail::service_base<select_reactor>(io_service),
-    io_service_(use_service<io_service_impl>(io_service)),
-    mutex_(),
-    interrupter_(),
-#if defined(ASIO_HAS_IOCP)
-    stop_thread_(false),
-    thread_(0),
-#endif // defined(ASIO_HAS_IOCP)
-    shutdown_(false)
-{
-#if defined(ASIO_HAS_IOCP)
-  asio::detail::signal_blocker sb;
-  thread_ = new asio::detail::thread(
-      bind_handler(&select_reactor::call_run_thread, this));
-#endif // defined(ASIO_HAS_IOCP)
-}
-
-select_reactor::~select_reactor()
-{
-  shutdown_service();
-}
-
-void select_reactor::shutdown_service()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-#if defined(ASIO_HAS_IOCP)
-  stop_thread_ = true;
-#endif // defined(ASIO_HAS_IOCP)
-  lock.unlock();
-
-#if defined(ASIO_HAS_IOCP)
-  if (thread_)
-  {
-    interrupter_.interrupt();
-    thread_->join();
-    delete thread_;
-    thread_ = 0;
-  }
-#endif // defined(ASIO_HAS_IOCP)
-
-  op_queue<operation> ops;
-
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].get_all_operations(ops);
-
-  timer_queues_.get_all_timers(ops);
-}
-
-void select_reactor::init_task()
-{
-  io_service_.init_task();
-}
-
-int select_reactor::register_descriptor(socket_type,
-    select_reactor::per_descriptor_data&)
-{
-  return 0;
-}
-
-void select_reactor::start_op(int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op, bool)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (shutdown_)
-  {
-    post_immediate_completion(op);
-    return;
-  }
-
-  bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
-  io_service_.work_started();
-  if (first)
-    interrupter_.interrupt();
-}
-
-void select_reactor::cancel_ops(socket_type descriptor,
-    select_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void select_reactor::close_descriptor(socket_type descriptor,
-    select_reactor::per_descriptor_data&)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  cancel_ops_unlocked(descriptor, asio::error::operation_aborted);
-}
-
-void select_reactor::run(bool block, op_queue<operation>& ops)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-#if defined(ASIO_HAS_IOCP)
-  // Check if the thread is supposed to stop.
-  if (stop_thread_)
-    return;
-#endif // defined(ASIO_HAS_IOCP)
-
-  // Set up the descriptor sets.
-  fd_set_adapter fds[max_select_ops];
-  fds[read_op].set(interrupter_.read_descriptor());
-  socket_type max_fd = 0;
-  bool have_work_to_do = !timer_queues_.all_empty();
-  for (int i = 0; i < max_select_ops; ++i)
-  {
-    have_work_to_do = have_work_to_do || !op_queue_[i].empty();
-    op_queue_[i].get_descriptors(fds[i], ops);
-    if (fds[i].max_descriptor() > max_fd)
-      max_fd = fds[i].max_descriptor();
-  }
-
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  // Connection operations on Windows use both except and write fd_sets.
-  have_work_to_do = have_work_to_do || !op_queue_[connect_op].empty();
-  op_queue_[connect_op].get_descriptors(fds[write_op], ops);
-  if (fds[write_op].max_descriptor() > max_fd)
-    max_fd = fds[write_op].max_descriptor();
-  op_queue_[connect_op].get_descriptors(fds[except_op], ops);
-  if (fds[except_op].max_descriptor() > max_fd)
-    max_fd = fds[except_op].max_descriptor();
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-  // We can return immediately if there's no work to do and the reactor is
-  // not supposed to block.
-  if (!block && !have_work_to_do)
-    return;
-
-  // Determine how long to block while waiting for events.
-  timeval tv_buf = { 0, 0 };
-  timeval* tv = block ? get_timeout(tv_buf) : &tv_buf;
-
-  lock.unlock();
-
-  // Block on the select call until descriptors become ready.
-  asio::error_code ec;
-  int retval = socket_ops::select(static_cast<int>(max_fd + 1),
-      fds[read_op], fds[write_op], fds[except_op], tv, ec);
-
-  // Reset the interrupter.
-  if (retval > 0 && fds[read_op].is_set(interrupter_.read_descriptor()))
-    interrupter_.reset();
-
-  lock.lock();
-
-  // Dispatch all ready operations.
-  if (retval > 0)
-  {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-    // Connection operations on Windows use both except and write fd_sets.
-    op_queue_[connect_op].perform_operations_for_descriptors(
-        fds[except_op], ops);
-    op_queue_[connect_op].perform_operations_for_descriptors(
-        fds[write_op], ops);
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-    // Exception operations must be processed first to ensure that any
-    // out-of-band data is read before normal data.
-    for (int i = max_select_ops - 1; i >= 0; --i)
-      op_queue_[i].perform_operations_for_descriptors(fds[i], ops);
-  }
-  timer_queues_.get_ready_timers(ops);
-}
-
-void select_reactor::interrupt()
-{
-  interrupter_.interrupt();
-}
-
-#if defined(ASIO_HAS_IOCP)
-void select_reactor::run_thread()
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  while (!stop_thread_)
-  {
-    lock.unlock();
-    op_queue<operation> ops;
-    run(true, ops);
-    io_service_.post_deferred_completions(ops);
-    lock.lock();
-  }
-}
-
-void select_reactor::call_run_thread(select_reactor* reactor)
-{
-  reactor->run_thread();
-}
-#endif // defined(ASIO_HAS_IOCP)
-
-void select_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.insert(&queue);
-}
-
-void select_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(mutex_);
-  timer_queues_.erase(&queue);
-}
-
-timeval* select_reactor::get_timeout(timeval& tv)
-{
-  // By default we will wait no longer than 5 minutes. This will ensure that
-  // any changes to the system clock are detected after no longer than this.
-  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
-  tv.tv_sec = usec / 1000000;
-  tv.tv_usec = usec % 1000000;
-  return &tv;
-}
-
-void select_reactor::cancel_ops_unlocked(socket_type descriptor,
-    const asio::error_code& ec)
-{
-  bool need_interrupt = false;
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    need_interrupt = op_queue_[i].cancel_operations(
-        descriptor, ops, ec) || need_interrupt;
-  io_service_.post_deferred_completions(ops);
-  if (need_interrupt)
-    interrupter_.interrupt();
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-       //   || (!defined(ASIO_HAS_DEV_POLL)
-       //       && !defined(ASIO_HAS_EPOLL)
-       //       && !defined(ASIO_HAS_KQUEUE))
-
-#endif // ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP

ext/asio/asio/detail/impl/service_registry.hpp

@@ -1,70 +0,0 @@
-//
-// detail/impl/service_registry.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
-#define ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Service>
-Service& service_registry::use_service()
-{
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
-  factory_type factory = &service_registry::create<Service>;
-  return *static_cast<Service*>(do_use_service(key, factory));
-}
-
-template <typename Service>
-void service_registry::add_service(Service* new_service)
-{
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
-  return do_add_service(key, new_service);
-}
-
-template <typename Service>
-bool service_registry::has_service() const
-{
-  asio::io_service::service::key key;
-  init_key(key, Service::id);
-  return do_has_service(key);
-}
-
-#if !defined(ASIO_NO_TYPEID)
-template <typename Service>
-void service_registry::init_key(asio::io_service::service::key& key,
-    const asio::detail::service_id<Service>& /*id*/)
-{
-  key.type_info_ = &typeid(typeid_wrapper<Service>);
-  key.id_ = 0;
-}
-#endif // !defined(ASIO_NO_TYPEID)
-
-template <typename Service>
-asio::io_service::service* service_registry::create(
-    asio::io_service& owner)
-{
-  return new Service(owner);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP

ext/asio/asio/detail/impl/service_registry.ipp

@@ -1,164 +0,0 @@
-//
-// detail/impl/service_registry.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
-#define ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <boost/throw_exception.hpp>
-#include "asio/detail/service_registry.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-service_registry::service_registry(asio::io_service& o)
-  : owner_(o),
-    first_service_(0)
-{
-}
-
-service_registry::~service_registry()
-{
-  // Shutdown all services. This must be done in a separate loop before the
-  // services are destroyed since the destructors of user-defined handler
-  // objects may try to access other service objects.
-  asio::io_service::service* service = first_service_;
-  while (service)
-  {
-    service->shutdown_service();
-    service = service->next_;
-  }
-
-  // Destroy all services.
-  while (first_service_)
-  {
-    asio::io_service::service* next_service = first_service_->next_;
-    destroy(first_service_);
-    first_service_ = next_service;
-  }
-}
-
-void service_registry::init_key(asio::io_service::service::key& key,
-    const asio::io_service::id& id)
-{
-  key.type_info_ = 0;
-  key.id_ = &id;
-}
-
-bool service_registry::keys_match(
-    const asio::io_service::service::key& key1,
-    const asio::io_service::service::key& key2)
-{
-  if (key1.id_ && key2.id_)
-    if (key1.id_ == key2.id_)
-      return true;
-  if (key1.type_info_ && key2.type_info_)
-    if (*key1.type_info_ == *key2.type_info_)
-      return true;
-  return false;
-}
-
-void service_registry::destroy(asio::io_service::service* service)
-{
-  delete service;
-}
-
-asio::io_service::service* service_registry::do_use_service(
-    const asio::io_service::service::key& key,
-    factory_type factory)
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // First see if there is an existing service object with the given key.
-  asio::io_service::service* service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      return service;
-    service = service->next_;
-  }
-
-  // Create a new service object. The service registry's mutex is not locked
-  // at this time to allow for nested calls into this function from the new
-  // service's constructor.
-  lock.unlock();
-  auto_service_ptr new_service = { factory(owner_) };
-  new_service.ptr_->key_ = key;
-  lock.lock();
-
-  // Check that nobody else created another service object of the same type
-  // while the lock was released.
-  service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      return service;
-    service = service->next_;
-  }
-
-  // Service was successfully initialised, pass ownership to registry.
-  new_service.ptr_->next_ = first_service_;
-  first_service_ = new_service.ptr_;
-  new_service.ptr_ = 0;
-  return first_service_;
-}
-
-void service_registry::do_add_service(
-    const asio::io_service::service::key& key,
-    asio::io_service::service* new_service)
-{
-  if (&owner_ != &new_service->io_service())
-    boost::throw_exception(invalid_service_owner());
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Check if there is an existing service object with the given key.
-  asio::io_service::service* service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      boost::throw_exception(service_already_exists());
-    service = service->next_;
-  }
-
-  // Take ownership of the service object.
-  new_service->key_ = key;
-  new_service->next_ = first_service_;
-  first_service_ = new_service;
-}
-
-bool service_registry::do_has_service(
-    const asio::io_service::service::key& key) const
-{
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  asio::io_service::service* service = first_service_;
-  while (service)
-  {
-    if (keys_match(service->key_, key))
-      return true;
-    service = service->next_;
-  }
-
-  return false;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP

ext/asio/asio/detail/impl/socket_select_interrupter.ipp

@@ -1,151 +0,0 @@
-//
-// detail/impl/socket_select_interrupter.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
-#define ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(BOOST_WINDOWS) \
-  || defined(__CYGWIN__) \
-  || defined(__SYMBIAN32__)
-
-#include <cstdlib>
-#include "asio/detail/socket_holder.hpp"
-#include "asio/detail/socket_ops.hpp"
-#include "asio/detail/socket_select_interrupter.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-socket_select_interrupter::socket_select_interrupter()
-{
-  asio::error_code ec;
-  socket_holder acceptor(socket_ops::socket(
-        AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
-  if (acceptor.get() == invalid_socket)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  int opt = 1;
-  socket_ops::state_type acceptor_state = 0;
-  socket_ops::setsockopt(acceptor.get(), acceptor_state,
-      SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt), ec);
-
-  using namespace std; // For memset.
-  sockaddr_in4_type addr;
-  std::size_t addr_len = sizeof(addr);
-  memset(&addr, 0, sizeof(addr));
-  addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
-  addr.sin_port = 0;
-  if (socket_ops::bind(acceptor.get(), (const socket_addr_type*)&addr,
-        addr_len, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  if (socket_ops::getsockname(acceptor.get(), (socket_addr_type*)&addr,
-        &addr_len, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  // Some broken firewalls on Windows will intermittently cause getsockname to
-  // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We
-  // explicitly specify the target address here to work around this problem.
-  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
-
-  if (socket_ops::listen(acceptor.get(),
-        SOMAXCONN, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  socket_holder client(socket_ops::socket(
-        AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
-  if (client.get() == invalid_socket)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  if (socket_ops::connect(client.get(), (const socket_addr_type*)&addr,
-        addr_len, ec) == socket_error_retval)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  socket_holder server(socket_ops::accept(acceptor.get(), 0, 0, ec));
-  if (server.get() == invalid_socket)
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-  
-  ioctl_arg_type non_blocking = 1;
-  socket_ops::state_type client_state = 0;
-  if (socket_ops::ioctl(client.get(), client_state,
-        FIONBIO, &non_blocking, ec))
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  opt = 1;
-  socket_ops::setsockopt(client.get(), client_state,
-      IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
-
-  non_blocking = 1;
-  socket_ops::state_type server_state = 0;
-  if (socket_ops::ioctl(server.get(), server_state,
-        FIONBIO, &non_blocking, ec))
-    asio::detail::throw_error(ec, "socket_select_interrupter");
-
-  opt = 1;
-  socket_ops::setsockopt(server.get(), server_state,
-      IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
-
-  read_descriptor_ = server.release();
-  write_descriptor_ = client.release();
-}
-
-socket_select_interrupter::~socket_select_interrupter()
-{
-  asio::error_code ec;
-  socket_ops::state_type state = socket_ops::internal_non_blocking;
-  if (read_descriptor_ != invalid_socket)
-    socket_ops::close(read_descriptor_, state, true, ec);
-  if (write_descriptor_ != invalid_socket)
-    socket_ops::close(write_descriptor_, state, true, ec);
-}
-
-void socket_select_interrupter::interrupt()
-{
-  char byte = 0;
-  socket_ops::buf b;
-  socket_ops::init_buf(b, &byte, 1);
-  asio::error_code ec;
-  socket_ops::send(write_descriptor_, &b, 1, 0, ec);
-}
-
-bool socket_select_interrupter::reset()
-{
-  char data[1024];
-  socket_ops::buf b;
-  socket_ops::init_buf(b, data, sizeof(data));
-  asio::error_code ec;
-  int bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec);
-  bool was_interrupted = (bytes_read > 0);
-  while (bytes_read == sizeof(data))
-    bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec);
-  return was_interrupted;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(BOOST_WINDOWS)
-       // || defined(__CYGWIN__)
-       // || defined(__SYMBIAN32__)
-
-#endif // ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP

ext/asio/asio/detail/impl/strand_service.hpp

@@ -1,140 +0,0 @@
-//
-// detail/impl/strand_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-inline strand_service::strand_impl::strand_impl()
-  : operation(&strand_service::do_complete),
-    count_(0)
-{
-}
-
-struct strand_service::on_dispatch_exit
-{
-  io_service_impl* io_service_;
-  strand_impl* impl_;
-
-  ~on_dispatch_exit()
-  {
-    impl_->mutex_.lock();
-    bool more_handlers = (--impl_->count_ > 0);
-    impl_->mutex_.unlock();
-
-    if (more_handlers)
-      io_service_->post_immediate_completion(impl_);
-  }
-};
-
-inline void strand_service::destroy(strand_service::implementation_type& impl)
-{
-  impl = 0;
-}
-
-template <typename Handler>
-void strand_service::dispatch(strand_service::implementation_type& impl,
-    Handler handler)
-{
-  // If we are already in the strand then the handler can run immediately.
-  if (call_stack<strand_impl>::contains(impl))
-  {
-    asio::detail::fenced_block b;
-    asio_handler_invoke_helpers::invoke(handler, handler);
-    return;
-  }
-
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
-  p.p = new (p.v) op(handler);
-
-  // If we are running inside the io_service, and no other handler is queued
-  // or running, then the handler can run immediately.
-  bool can_dispatch = call_stack<io_service_impl>::contains(&io_service_);
-  impl->mutex_.lock();
-  bool first = (++impl->count_ == 1);
-  if (can_dispatch && first)
-  {
-    // Immediate invocation is allowed.
-    impl->mutex_.unlock();
-
-    // Memory must be releaesed before any upcall is made.
-    p.reset();
-
-    // Indicate that this strand is executing on the current thread.
-    call_stack<strand_impl>::context ctx(impl);
-
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_dispatch_exit on_exit = { &io_service_, impl };
-    (void)on_exit;
-
-    asio::detail::fenced_block b;
-    asio_handler_invoke_helpers::invoke(handler, handler);
-    return;
-  }
-
-  // Immediate invocation is not allowed, so enqueue for later.
-  impl->queue_.push(p.p);
-  impl->mutex_.unlock();
-  p.v = p.p = 0;
-
-  // The first handler to be enqueued is responsible for scheduling the
-  // strand.
-  if (first)
-    io_service_.post_immediate_completion(impl);
-}
-
-// Request the io_service to invoke the given handler and return immediately.
-template <typename Handler>
-void strand_service::post(strand_service::implementation_type& impl,
-    Handler handler)
-{
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
-  p.p = new (p.v) op(handler);
-
-  // Add the handler to the queue.
-  impl->mutex_.lock();
-  bool first = (++impl->count_ == 1);
-  impl->queue_.push(p.p);
-  impl->mutex_.unlock();
-  p.v = p.p = 0;
-
-  // The first handler to be enqueue is responsible for scheduling the strand.
-  if (first)
-    io_service_.post_immediate_completion(impl);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP

ext/asio/asio/detail/impl/strand_service.ipp

@@ -1,106 +0,0 @@
-//
-// detail/impl/strand_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/strand_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct strand_service::on_do_complete_exit
-{
-  io_service_impl* owner_;
-  strand_impl* impl_;
-
-  ~on_do_complete_exit()
-  {
-    impl_->mutex_.lock();
-    bool more_handlers = (--impl_->count_ > 0);
-    impl_->mutex_.unlock();
-
-    if (more_handlers)
-      owner_->post_immediate_completion(impl_);
-  }
-};
-
-strand_service::strand_service(asio::io_service& io_service)
-  : asio::detail::service_base<strand_service>(io_service),
-    io_service_(asio::use_service<io_service_impl>(io_service)),
-    mutex_(),
-    salt_(0)
-{
-}
-
-void strand_service::shutdown_service()
-{
-  op_queue<operation> ops;
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  for (std::size_t i = 0; i < num_implementations; ++i)
-    if (strand_impl* impl = implementations_[i].get())
-      ops.push(impl->queue_);
-}
-
-void strand_service::construct(strand_service::implementation_type& impl)
-{
-  std::size_t salt = salt_++;
-  std::size_t index = reinterpret_cast<std::size_t>(&impl);
-  index += (reinterpret_cast<std::size_t>(&impl) >> 3);
-  index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2);
-  index = index % num_implementations;
-
-  asio::detail::mutex::scoped_lock lock(mutex_);
-
-  if (!implementations_[index])
-    implementations_[index].reset(new strand_impl);
-  impl = implementations_[index].get();
-}
-
-void strand_service::do_complete(io_service_impl* owner, operation* base,
-    asio::error_code /*ec*/, std::size_t /*bytes_transferred*/)
-{
-  if (owner)
-  {
-    strand_impl* impl = static_cast<strand_impl*>(base);
-
-    // Get the next handler to be executed.
-    impl->mutex_.lock();
-    operation* o = impl->queue_.front();
-    impl->queue_.pop();
-    impl->mutex_.unlock();
-
-    // Indicate that this strand is executing on the current thread.
-    call_stack<strand_impl>::context ctx(impl);
-
-    // Ensure the next handler, if any, is scheduled on block exit.
-    on_do_complete_exit on_exit = { owner, impl };
-    (void)on_exit;
-
-    o->complete(*owner);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP

ext/asio/asio/detail/impl/task_io_service.hpp

@@ -1,60 +0,0 @@
-//
-// detail/impl/task_io_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler>
-void task_io_service::dispatch(Handler handler)
-{
-  if (call_stack<task_io_service>::contains(this))
-  {
-    asio::detail::fenced_block b;
-    asio_handler_invoke_helpers::invoke(handler, handler);
-  }
-  else
-    post(handler);
-}
-
-template <typename Handler>
-void task_io_service::post(Handler handler)
-{
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
-  p.p = new (p.v) op(handler);
-
-  post_immediate_completion(p.p);
-  p.v = p.p = 0;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP

ext/asio/asio/detail/impl/task_io_service.ipp

@@ -1,354 +0,0 @@
-//
-// detail/impl/task_io_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HAS_IOCP)
-
-#include <boost/limits.hpp>
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/event.hpp"
-#include "asio/detail/reactor.hpp"
-#include "asio/detail/task_io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct task_io_service::task_cleanup
-{
-  ~task_cleanup()
-  {
-    // Enqueue the completed operations and reinsert the task at the end of
-    // the operation queue.
-    lock_->lock();
-    task_io_service_->task_interrupted_ = true;
-    task_io_service_->op_queue_.push(*ops_);
-    task_io_service_->op_queue_.push(&task_io_service_->task_operation_);
-  }
-
-  task_io_service* task_io_service_;
-  mutex::scoped_lock* lock_;
-  op_queue<operation>* ops_;
-};
-
-struct task_io_service::work_finished_on_block_exit
-{
-  ~work_finished_on_block_exit()
-  {
-    task_io_service_->work_finished();
-  }
-
-  task_io_service* task_io_service_;
-};
-
-struct task_io_service::idle_thread_info
-{
-  event wakeup_event;
-  idle_thread_info* next;
-};
-
-task_io_service::task_io_service(asio::io_service& io_service)
-  : asio::detail::service_base<task_io_service>(io_service),
-    mutex_(),
-    task_(0),
-    task_interrupted_(true),
-    outstanding_work_(0),
-    stopped_(false),
-    shutdown_(false),
-    first_idle_thread_(0)
-{
-}
-
-void task_io_service::init(std::size_t /*concurrency_hint*/)
-{
-}
-
-void task_io_service::shutdown_service()
-{
-  mutex::scoped_lock lock(mutex_);
-  shutdown_ = true;
-  lock.unlock();
-
-  // Destroy handler objects.
-  while (!op_queue_.empty())
-  {
-    operation* o = op_queue_.front();
-    op_queue_.pop();
-    if (o != &task_operation_)
-      o->destroy();
-  }
-
-  // Reset to initial state.
-  task_ = 0;
-}
-
-void task_io_service::init_task()
-{
-  mutex::scoped_lock lock(mutex_);
-  if (!shutdown_ && !task_)
-  {
-    task_ = &use_service<reactor>(this->get_io_service());
-    op_queue_.push(&task_operation_);
-    wake_one_thread_and_unlock(lock);
-  }
-}
-
-std::size_t task_io_service::run(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  call_stack<task_io_service>::context ctx(this);
-
-  idle_thread_info this_idle_thread;
-  this_idle_thread.next = 0;
-
-  mutex::scoped_lock lock(mutex_);
-
-  std::size_t n = 0;
-  for (; do_one(lock, &this_idle_thread); lock.lock())
-    if (n != (std::numeric_limits<std::size_t>::max)())
-      ++n;
-  return n;
-}
-
-std::size_t task_io_service::run_one(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  call_stack<task_io_service>::context ctx(this);
-
-  idle_thread_info this_idle_thread;
-  this_idle_thread.next = 0;
-
-  mutex::scoped_lock lock(mutex_);
-
-  return do_one(lock, &this_idle_thread);
-}
-
-std::size_t task_io_service::poll(asio::error_code& ec)
-{
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  call_stack<task_io_service>::context ctx(this);
-
-  mutex::scoped_lock lock(mutex_);
-
-  std::size_t n = 0;
-  for (; do_one(lock, 0); lock.lock())
-    if (n != (std::numeric_limits<std::size_t>::max)())
-      ++n;
-  return n;
-}
-
-std::size_t task_io_service::poll_one(asio::error_code& ec)
-{
-  ec = asio::error_code();
-  if (outstanding_work_ == 0)
-  {
-    stop();
-    return 0;
-  }
-
-  call_stack<task_io_service>::context ctx(this);
-
-  mutex::scoped_lock lock(mutex_);
-
-  return do_one(lock, 0);
-}
-
-void task_io_service::stop()
-{
-  mutex::scoped_lock lock(mutex_);
-  stop_all_threads(lock);
-}
-
-void task_io_service::reset()
-{
-  mutex::scoped_lock lock(mutex_);
-  stopped_ = false;
-}
-
-void task_io_service::post_immediate_completion(task_io_service::operation* op)
-{
-  work_started();
-  post_deferred_completion(op);
-}
-
-void task_io_service::post_deferred_completion(task_io_service::operation* op)
-{
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(op);
-  wake_one_thread_and_unlock(lock);
-}
-
-void task_io_service::post_deferred_completions(
-    op_queue<task_io_service::operation>& ops)
-{
-  if (!ops.empty())
-  {
-    mutex::scoped_lock lock(mutex_);
-    op_queue_.push(ops);
-    wake_one_thread_and_unlock(lock);
-  }
-}
-
-std::size_t task_io_service::do_one(mutex::scoped_lock& lock,
-    task_io_service::idle_thread_info* this_idle_thread)
-{
-  bool polling = !this_idle_thread;
-  bool task_has_run = false;
-  while (!stopped_)
-  {
-    if (!op_queue_.empty())
-    {
-      // Prepare to execute first handler from queue.
-      operation* o = op_queue_.front();
-      op_queue_.pop();
-      bool more_handlers = (!op_queue_.empty());
-
-      if (o == &task_operation_)
-      {
-        task_interrupted_ = more_handlers || polling;
-
-        // If the task has already run and we're polling then we're done.
-        if (task_has_run && polling)
-        {
-          task_interrupted_ = true;
-          op_queue_.push(&task_operation_);
-          return 0;
-        }
-        task_has_run = true;
-
-        if (!more_handlers || !wake_one_idle_thread_and_unlock(lock))
-          lock.unlock();
-
-        op_queue<operation> completed_ops;
-        task_cleanup c = { this, &lock, &completed_ops };
-        (void)c;
-
-        // Run the task. May throw an exception. Only block if the operation
-        // queue is empty and we're not polling, otherwise we want to return
-        // as soon as possible.
-        task_->run(!more_handlers && !polling, completed_ops);
-      }
-      else
-      {
-        if (more_handlers)
-          wake_one_thread_and_unlock(lock);
-        else
-          lock.unlock();
-
-        // Ensure the count of outstanding work is decremented on block exit.
-        work_finished_on_block_exit on_exit = { this };
-        (void)on_exit;
-
-        // Complete the operation. May throw an exception.
-        o->complete(*this); // deletes the operation object
-
-        return 1;
-      }
-    }
-    else if (this_idle_thread)
-    {
-      // Nothing to run right now, so just wait for work to do.
-      this_idle_thread->next = first_idle_thread_;
-      first_idle_thread_ = this_idle_thread;
-      this_idle_thread->wakeup_event.clear(lock);
-      this_idle_thread->wakeup_event.wait(lock);
-    }
-    else
-    {
-      return 0;
-    }
-  }
-
-  return 0;
-}
-
-void task_io_service::stop_all_threads(
-    mutex::scoped_lock& lock)
-{
-  stopped_ = true;
-
-  while (first_idle_thread_)
-  {
-    idle_thread_info* idle_thread = first_idle_thread_;
-    first_idle_thread_ = idle_thread->next;
-    idle_thread->next = 0;
-    idle_thread->wakeup_event.signal(lock);
-  }
-
-  if (!task_interrupted_ && task_)
-  {
-    task_interrupted_ = true;
-    task_->interrupt();
-  }
-}
-
-bool task_io_service::wake_one_idle_thread_and_unlock(
-    mutex::scoped_lock& lock)
-{
-  if (first_idle_thread_)
-  {
-    idle_thread_info* idle_thread = first_idle_thread_;
-    first_idle_thread_ = idle_thread->next;
-    idle_thread->next = 0;
-    idle_thread->wakeup_event.signal_and_unlock(lock);
-    return true;
-  }
-  return false;
-}
-
-void task_io_service::wake_one_thread_and_unlock(
-    mutex::scoped_lock& lock)
-{
-  if (!wake_one_idle_thread_and_unlock(lock))
-  {
-    if (!task_interrupted_ && task_)
-    {
-      task_interrupted_ = true;
-      task_->interrupt();
-    }
-    lock.unlock();
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP

ext/asio/asio/detail/impl/throw_error.ipp

@@ -1,47 +0,0 @@
-//
-// detail/impl/throw_error.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_THROW_ERROR_IPP
-#define ASIO_DETAIL_IMPL_THROW_ERROR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include <boost/throw_exception.hpp>
-#include "asio/detail/throw_error.hpp"
-#include "asio/system_error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-ASIO_DECL
-void do_throw_error(const asio::error_code& err)
-{
-  asio::system_error e(err);
-  boost::throw_exception(e);
-}
-
-ASIO_DECL
-void do_throw_error(const asio::error_code& err, const char* location)
-{
-  asio::system_error e(err, location);
-  boost::throw_exception(e);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_THROW_ERROR_IPP

ext/asio/asio/detail/impl/timer_queue.ipp

@@ -1,85 +0,0 @@
-//
-// detail/impl/timer_queue.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TIMER_QUEUE_IPP
-#define ASIO_DETAIL_IMPL_TIMER_QUEUE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if !defined(ASIO_HEADER_ONLY)
-
-#include "asio/detail/timer_queue.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue()
-{
-}
-
-timer_queue<time_traits<boost::posix_time::ptime> >::~timer_queue()
-{
-}
-
-bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
-    const time_type& time, per_timer_data& timer, timer_op* op)
-{
-  return impl_.enqueue_timer(time, timer, op);
-}
-
-bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
-{
-  return impl_.empty();
-}
-
-long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_msec(
-    long max_duration) const
-{
-  return impl_.wait_duration_msec(max_duration);
-}
-
-long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_usec(
-    long max_duration) const
-{
-  return impl_.wait_duration_usec(max_duration);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime> >::get_ready_timers(
-    op_queue<operation>& ops)
-{
-  impl_.get_ready_timers(ops);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime> >::get_all_timers(
-    op_queue<operation>& ops)
-{
-  impl_.get_all_timers(ops);
-}
-
-std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
-    per_timer_data& timer, op_queue<operation>& ops)
-{
-  return impl_.cancel_timer(timer, ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // !defined(ASIO_HEADER_ONLY)
-
-#endif // ASIO_DETAIL_IMPL_TIMER_QUEUE_IPP

ext/asio/asio/detail/impl/timer_queue_set.ipp

@@ -1,101 +0,0 @@
-//
-// detail/impl/timer_queue_set.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
-#define ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-#include "asio/detail/timer_queue_set.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-timer_queue_set::timer_queue_set()
-  : first_(0)
-{
-}
-
-void timer_queue_set::insert(timer_queue_base* q)
-{
-  q->next_ = first_;
-  first_ = q;
-}
-
-void timer_queue_set::erase(timer_queue_base* q)
-{
-  if (first_)
-  {
-    if (q == first_)
-    {
-      first_ = q->next_;
-      q->next_ = 0;
-      return;
-    }
-
-    for (timer_queue_base* p = first_; p->next_; p = p->next_)
-    {
-      if (p->next_ == q)
-      {
-        p->next_ = q->next_;
-        q->next_ = 0;
-        return;
-      }
-    }
-  }
-}
-
-bool timer_queue_set::all_empty() const
-{
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    if (!p->empty())
-      return false;
-  return true;
-}
-
-long timer_queue_set::wait_duration_msec(long max_duration) const
-{
-  long min_duration = max_duration;
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    min_duration = p->wait_duration_msec(min_duration);
-  return min_duration;
-}
-
-long timer_queue_set::wait_duration_usec(long max_duration) const
-{
-  long min_duration = max_duration;
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    min_duration = p->wait_duration_usec(min_duration);
-  return min_duration;
-}
-
-void timer_queue_set::get_ready_timers(op_queue<operation>& ops)
-{
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    p->get_ready_timers(ops);
-}
-
-void timer_queue_set::get_all_timers(op_queue<operation>& ops)
-{
-  for (timer_queue_base* p = first_; p; p = p->next_)
-    p->get_all_timers(ops);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP

ext/asio/asio/detail/impl/win_event.ipp

@@ -1,50 +0,0 @@
-//
-// detail/win_event.ipp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_EVENT_IPP
-#define ASIO_DETAIL_IMPL_WIN_EVENT_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(BOOST_WINDOWS)
-
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_event.hpp"
-#include "asio/error.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_event::win_event()
-  : event_(::CreateEvent(0, true, false, 0))
-{
-  if (!event_)
-  {
-    DWORD last_error = ::GetLastError();
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "event");
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(BOOST_WINDOWS)
-
-#endif // ASIO_DETAIL_IMPL_WIN_EVENT_IPP

ext/asio/asio/detail/impl/win_iocp_handle_service.ipp

@@ -1,452 +0,0 @@
-//
-// detail/impl/win_iocp_handle_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/win_iocp_handle_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-class win_iocp_handle_service::overlapped_wrapper
-  : public OVERLAPPED
-{
-public:
-  explicit overlapped_wrapper(asio::error_code& ec)
-  {
-    Internal = 0;
-    InternalHigh = 0;
-    Offset = 0;
-    OffsetHigh = 0;
-
-    // Create a non-signalled manual-reset event, for GetOverlappedResult.
-    hEvent = ::CreateEvent(0, TRUE, FALSE, 0);
-    if (hEvent)
-    {
-      // As documented in GetQueuedCompletionStatus, setting the low order
-      // bit of this event prevents our synchronous writes from being treated
-      // as completion port events.
-      *reinterpret_cast<DWORD_PTR*>(&hEvent) |= 1;
-    }
-    else
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-  }
-
-  ~overlapped_wrapper()
-  {
-    if (hEvent)
-    {
-      ::CloseHandle(hEvent);
-    }
-  }
-};
-
-win_iocp_handle_service::win_iocp_handle_service(
-    asio::io_service& io_service)
-  : iocp_service_(asio::use_service<win_iocp_io_service>(io_service)),
-    mutex_(),
-    impl_list_(0)
-{
-}
-
-void win_iocp_handle_service::shutdown_service()
-{
-  // Close all implementations, causing all operations to complete.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  implementation_type* impl = impl_list_;
-  while (impl)
-  {
-    close_for_destruction(*impl);
-    impl = impl->next_;
-  }
-}
-
-void win_iocp_handle_service::construct(
-    win_iocp_handle_service::implementation_type& impl)
-{
-  impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.safe_cancellation_thread_id_ = 0;
-
-  // Insert implementation into linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  impl.next_ = impl_list_;
-  impl.prev_ = 0;
-  if (impl_list_)
-    impl_list_->prev_ = &impl;
-  impl_list_ = &impl;
-}
-
-void win_iocp_handle_service::destroy(
-    win_iocp_handle_service::implementation_type& impl)
-{
-  close_for_destruction(impl);
-  
-  // Remove implementation from linked list of all implementations.
-  asio::detail::mutex::scoped_lock lock(mutex_);
-  if (impl_list_ == &impl)
-    impl_list_ = impl.next_;
-  if (impl.prev_)
-    impl.prev_->next_ = impl.next_;
-  if (impl.next_)
-    impl.next_->prev_= impl.prev_;
-  impl.next_ = 0;
-  impl.prev_ = 0;
-}
-
-asio::error_code win_iocp_handle_service::assign(
-    win_iocp_handle_service::implementation_type& impl,
-    const native_type& native_handle, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  if (iocp_service_.register_handle(native_handle, ec))
-    return ec;
-
-  impl.handle_ = native_handle;
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_iocp_handle_service::close(
-    win_iocp_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    if (!::CloseHandle(impl.handle_))
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-      return ec;
-    }
-
-    impl.handle_ = INVALID_HANDLE_VALUE;
-    impl.safe_cancellation_thread_id_ = 0;
-  }
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_iocp_handle_service::cancel(
-    win_iocp_handle_service::implementation_type& impl,
-    asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-  }
-  else if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
-        ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
-  {
-    // The version of Windows supports cancellation from any thread.
-    typedef BOOL (WINAPI* cancel_io_ex_t)(HANDLE, LPOVERLAPPED);
-    cancel_io_ex_t cancel_io_ex = (cancel_io_ex_t)cancel_io_ex_ptr;
-    if (!cancel_io_ex(impl.handle_, 0))
-    {
-      DWORD last_error = ::GetLastError();
-      if (last_error == ERROR_NOT_FOUND)
-      {
-        // ERROR_NOT_FOUND means that there were no operations to be
-        // cancelled. We swallow this error to match the behaviour on other
-        // platforms.
-        ec = asio::error_code();
-      }
-      else
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-      }
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-  }
-  else if (impl.safe_cancellation_thread_id_ == 0)
-  {
-    // No operations have been started, so there's nothing to cancel.
-    ec = asio::error_code();
-  }
-  else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId())
-  {
-    // Asynchronous operations have been started from the current thread only,
-    // so it is safe to try to cancel them using CancelIo.
-    if (!::CancelIo(impl.handle_))
-    {
-      DWORD last_error = ::GetLastError();
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-    else
-    {
-      ec = asio::error_code();
-    }
-  }
-  else
-  {
-    // Asynchronous operations have been started from more than one thread,
-    // so cancellation is not safe.
-    ec = asio::error::operation_not_supported;
-  }
-
-  return ec;
-}
-
-size_t win_iocp_handle_service::do_write(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
-    const asio::const_buffer& buffer, asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // A request to write 0 bytes on a handle is a no-op.
-  if (asio::buffer_size(buffer) == 0)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  overlapped_wrapper overlapped(ec);
-  if (ec)
-  {
-    return 0;
-  }
-
-  // Write the data. 
-  overlapped.Offset = offset & 0xFFFFFFFF;
-  overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-  BOOL ok = ::WriteFile(impl.handle_,
-      asio::buffer_cast<LPCVOID>(buffer),
-      static_cast<DWORD>(asio::buffer_size(buffer)), 0, &overlapped);
-  if (!ok) 
-  {
-    DWORD last_error = ::GetLastError();
-    if (last_error != ERROR_IO_PENDING)
-    {
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-      return 0;
-    }
-  }
-
-  // Wait for the operation to complete.
-  DWORD bytes_transferred = 0;
-  ok = ::GetOverlappedResult(impl.handle_,
-      &overlapped, &bytes_transferred, TRUE);
-  if (!ok)
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return 0;
-  }
-
-  ec = asio::error_code();
-  return bytes_transferred;
-}
-
-void win_iocp_handle_service::start_write_op(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
-    const asio::const_buffer& buffer, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-  {
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  }
-  else if (asio::buffer_size(buffer) == 0)
-  {
-    // A request to write 0 bytes on a handle is a no-op.
-    iocp_service_.on_completion(op);
-  }
-  else
-  {
-    DWORD bytes_transferred = 0;
-    op->Offset = offset & 0xFFFFFFFF;
-    op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-    BOOL ok = ::WriteFile(impl.handle_,
-        asio::buffer_cast<LPCVOID>(buffer),
-        static_cast<DWORD>(asio::buffer_size(buffer)),
-        &bytes_transferred, op);
-    DWORD last_error = ::GetLastError();
-    if (!ok && last_error != ERROR_IO_PENDING
-        && last_error != ERROR_MORE_DATA)
-    {
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    }
-    else
-    {
-      iocp_service_.on_pending(op);
-    }
-  }
-}
-
-size_t win_iocp_handle_service::do_read(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
-    const asio::mutable_buffer& buffer, asio::error_code& ec)
-{
-  if (!is_open(impl))
-  {
-    ec = asio::error::bad_descriptor;
-    return 0;
-  }
-  
-  // A request to read 0 bytes on a stream handle is a no-op.
-  if (asio::buffer_size(buffer) == 0)
-  {
-    ec = asio::error_code();
-    return 0;
-  }
-
-  overlapped_wrapper overlapped(ec);
-  if (ec)
-  {
-    return 0;
-  }
-
-  // Read some data.
-  overlapped.Offset = offset & 0xFFFFFFFF;
-  overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-  BOOL ok = ::ReadFile(impl.handle_,
-      asio::buffer_cast<LPVOID>(buffer),
-      static_cast<DWORD>(asio::buffer_size(buffer)), 0, &overlapped);
-  if (!ok) 
-  {
-    DWORD last_error = ::GetLastError();
-    if (last_error != ERROR_IO_PENDING && last_error != ERROR_MORE_DATA)
-    {
-      if (last_error == ERROR_HANDLE_EOF)
-      {
-        ec = asio::error::eof;
-      }
-      else
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-      }
-      return 0;
-    }
-  }
-
-  // Wait for the operation to complete.
-  DWORD bytes_transferred = 0;
-  ok = ::GetOverlappedResult(impl.handle_,
-      &overlapped, &bytes_transferred, TRUE);
-  if (!ok)
-  {
-    DWORD last_error = ::GetLastError();
-    if (last_error == ERROR_HANDLE_EOF)
-    {
-      ec = asio::error::eof;
-    }
-    else
-    {
-      ec = asio::error_code(last_error,
-          asio::error::get_system_category());
-    }
-    return 0;
-  }
-
-  ec = asio::error_code();
-  return bytes_transferred;
-}
-
-void win_iocp_handle_service::start_read_op(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
-    const asio::mutable_buffer& buffer, operation* op)
-{
-  update_cancellation_thread_id(impl);
-  iocp_service_.work_started();
-
-  if (!is_open(impl))
-  {
-    iocp_service_.on_completion(op, asio::error::bad_descriptor);
-  }
-  else if (asio::buffer_size(buffer) == 0)
-  {
-    // A request to read 0 bytes on a handle is a no-op.
-    iocp_service_.on_completion(op);
-  }
-  else
-  {
-    DWORD bytes_transferred = 0;
-    op->Offset = offset & 0xFFFFFFFF;
-    op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
-    BOOL ok = ::ReadFile(impl.handle_,
-        asio::buffer_cast<LPVOID>(buffer),
-        static_cast<DWORD>(asio::buffer_size(buffer)),
-        &bytes_transferred, op);
-    DWORD last_error = ::GetLastError();
-    if (!ok && last_error != ERROR_IO_PENDING
-        && last_error != ERROR_MORE_DATA)
-    {
-      iocp_service_.on_completion(op, last_error, bytes_transferred);
-    }
-    else
-    {
-      iocp_service_.on_pending(op);
-    }
-  }
-}
-
-void win_iocp_handle_service::update_cancellation_thread_id(
-    win_iocp_handle_service::implementation_type& impl)
-{
-  if (impl.safe_cancellation_thread_id_ == 0)
-    impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId();
-  else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId())
-    impl.safe_cancellation_thread_id_ = ~DWORD(0);
-}
-
-void win_iocp_handle_service::close_for_destruction(implementation_type& impl)
-{
-  if (is_open(impl))
-  {
-    ::CloseHandle(impl.handle_);
-    impl.handle_ = INVALID_HANDLE_VALUE;
-    impl.safe_cancellation_thread_id_ = 0;
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP

ext/asio/asio/detail/impl/win_iocp_io_service.hpp

@@ -1,115 +0,0 @@
-//
-// detail/impl/win_iocp_io_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include "asio/detail/call_stack.hpp"
-#include "asio/detail/completion_handler.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-template <typename Handler>
-void win_iocp_io_service::dispatch(Handler handler)
-{
-  if (call_stack<win_iocp_io_service>::contains(this))
-  {
-    asio::detail::fenced_block b;
-    asio_handler_invoke_helpers::invoke(handler, handler);
-  }
-  else
-    post(handler);
-}
-
-template <typename Handler>
-void win_iocp_io_service::post(Handler handler)
-{
-  // Allocate and construct an operation to wrap the handler.
-  typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
-    asio_handler_alloc_helpers::allocate(
-      sizeof(op), handler), 0 };
-  p.p = new (p.v) op(handler);
-
-  post_immediate_completion(p.p);
-  p.v = p.p = 0;
-}
-
-template <typename Time_Traits>
-void win_iocp_io_service::add_timer_queue(
-    timer_queue<Time_Traits>& queue)
-{
-  do_add_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void win_iocp_io_service::remove_timer_queue(
-    timer_queue<Time_Traits>& queue)
-{
-  do_remove_timer_queue(queue);
-}
-
-template <typename Time_Traits>
-void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue,
-    const typename Time_Traits::time_type& time,
-    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
-{
-  // If the service has been shut down we silently discard the timer.
-  if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
-  {
-    post_immediate_completion(op);
-    return;
-  }
-
-  mutex::scoped_lock lock(dispatch_mutex_);
-
-  bool earliest = queue.enqueue_timer(time, timer, op);
-  work_started();
-  if (earliest)
-    update_timeout();
-}
-
-template <typename Time_Traits>
-std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer)
-{
-  // If the service has been shut down we silently ignore the cancellation.
-  if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
-    return 0;
-
-  mutex::scoped_lock lock(dispatch_mutex_);
-  op_queue<win_iocp_operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops);
-  post_deferred_completions(ops);
-  return n;
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP

ext/asio/asio/detail/impl/win_iocp_io_service.ipp

@@ -1,496 +0,0 @@
-//
-// detail/impl/win_iocp_io_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP)
-
-#include <boost/limits.hpp>
-#include "asio/error.hpp"
-#include "asio/io_service.hpp"
-#include "asio/detail/handler_alloc_helpers.hpp"
-#include "asio/detail/handler_invoke_helpers.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/detail/win_iocp_io_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-struct win_iocp_io_service::work_finished_on_block_exit
-{
-  ~work_finished_on_block_exit()
-  {
-    io_service_->work_finished();
-  }
-
-  win_iocp_io_service* io_service_;
-};
-
-struct win_iocp_io_service::timer_thread_function
-{
-  void operator()()
-  {
-    while (::InterlockedExchangeAdd(&io_service_->shutdown_, 0) == 0)
-    {
-      if (::WaitForSingleObject(io_service_->waitable_timer_.handle,
-            INFINITE) == WAIT_OBJECT_0)
-      {
-        ::InterlockedExchange(&io_service_->dispatch_required_, 1);
-        ::PostQueuedCompletionStatus(io_service_->iocp_.handle,
-            0, wake_for_dispatch, 0);
-      }
-    }
-  }
-
-  win_iocp_io_service* io_service_;
-};
-
-win_iocp_io_service::win_iocp_io_service(asio::io_service& io_service)
-  : asio::detail::service_base<win_iocp_io_service>(io_service),
-    iocp_(),
-    outstanding_work_(0),
-    stopped_(0),
-    shutdown_(0),
-    dispatch_required_(0)
-{
-}
-
-void win_iocp_io_service::init(size_t concurrency_hint)
-{
-  iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0,
-      static_cast<DWORD>((std::min<size_t>)(concurrency_hint, DWORD(~0))));
-  if (!iocp_.handle)
-  {
-    DWORD last_error = ::GetLastError();
-    asio::error_code ec(last_error,
-        asio::error::get_system_category());
-    asio::detail::throw_error(ec, "iocp");
-  }
-}
-
-void win_iocp_io_service::shutdown_service()
-{
-  ::InterlockedExchange(&shutdown_, 1);
-
-  if (timer_thread_)
-  {
-    LARGE_INTEGER timeout;
-    timeout.QuadPart = 1;
-    ::SetWaitableTimer(waitable_timer_.handle, &timeout, 1, 0, 0, FALSE);
-  }
-
-  while (::InterlockedExchangeAdd(&outstanding_work_, 0) > 0)
-  {
-    op_queue<win_iocp_operation> ops;
-    timer_queues_.get_all_timers(ops);
-    ops.push(completed_ops_);
-    if (!ops.empty())
-    {
-      while (win_iocp_operation* op = ops.front())
-      {
-        ops.pop();
-        ::InterlockedDecrement(&outstanding_work_);
-        op->destroy();
-      }
-    }
-    else
-    {
-      DWORD bytes_transferred = 0;
-      dword_ptr_t completion_key = 0;
-      LPOVERLAPPED overlapped = 0;
-      ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
-          &completion_key, &overlapped, gqcs_timeout);
-      if (overlapped)
-      {
-        ::InterlockedDecrement(&outstanding_work_);
-        static_cast<win_iocp_operation*>(overlapped)->destroy();
-      }
-    }
-  }
-
-  if (timer_thread_)
-    timer_thread_->join();
-}
-
-asio::error_code win_iocp_io_service::register_handle(
-    HANDLE handle, asio::error_code& ec)
-{
-  if (::CreateIoCompletionPort(handle, iocp_.handle, 0, 0) == 0)
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-  }
-  else
-  {
-    ec = asio::error_code();
-  }
-  return ec;
-}
-
-size_t win_iocp_io_service::run(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  call_stack<win_iocp_io_service>::context ctx(this);
-
-  size_t n = 0;
-  while (do_one(true, ec))
-    if (n != (std::numeric_limits<size_t>::max)())
-      ++n;
-  return n;
-}
-
-size_t win_iocp_io_service::run_one(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  call_stack<win_iocp_io_service>::context ctx(this);
-
-  return do_one(true, ec);
-}
-
-size_t win_iocp_io_service::poll(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  call_stack<win_iocp_io_service>::context ctx(this);
-
-  size_t n = 0;
-  while (do_one(false, ec))
-    if (n != (std::numeric_limits<size_t>::max)())
-      ++n;
-  return n;
-}
-
-size_t win_iocp_io_service::poll_one(asio::error_code& ec)
-{
-  if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
-  {
-    stop();
-    ec = asio::error_code();
-    return 0;
-  }
-
-  call_stack<win_iocp_io_service>::context ctx(this);
-
-  return do_one(false, ec);
-}
-
-void win_iocp_io_service::stop()
-{
-  if (::InterlockedExchange(&stopped_, 1) == 0)
-  {
-    if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
-    {
-      DWORD last_error = ::GetLastError();
-      asio::error_code ec(last_error,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "pqcs");
-    }
-  }
-}
-
-void win_iocp_io_service::post_deferred_completion(win_iocp_operation* op)
-{
-  // Flag the operation as ready.
-  op->ready_ = 1;
-
-  // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle,
-        0, overlapped_contains_result, op))
-  {
-    // Out of resources. Put on completed queue instead.
-    mutex::scoped_lock lock(dispatch_mutex_);
-    completed_ops_.push(op);
-    ::InterlockedExchange(&dispatch_required_, 1);
-  }
-}
-
-void win_iocp_io_service::post_deferred_completions(
-    op_queue<win_iocp_operation>& ops)
-{
-  while (win_iocp_operation* op = ops.front())
-  {
-    ops.pop();
-
-    // Flag the operation as ready.
-    op->ready_ = 1;
-
-    // Enqueue the operation on the I/O completion port.
-    if (!::PostQueuedCompletionStatus(iocp_.handle,
-          0, overlapped_contains_result, op))
-    {
-      // Out of resources. Put on completed queue instead.
-      mutex::scoped_lock lock(dispatch_mutex_);
-      completed_ops_.push(op);
-      completed_ops_.push(ops);
-      ::InterlockedExchange(&dispatch_required_, 1);
-    }
-  }
-}
-
-void win_iocp_io_service::on_pending(win_iocp_operation* op)
-{
-  if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
-  {
-    // Enqueue the operation on the I/O completion port.
-    if (!::PostQueuedCompletionStatus(iocp_.handle,
-          0, overlapped_contains_result, op))
-    {
-      // Out of resources. Put on completed queue instead.
-      mutex::scoped_lock lock(dispatch_mutex_);
-      completed_ops_.push(op);
-      ::InterlockedExchange(&dispatch_required_, 1);
-    }
-  }
-}
-
-void win_iocp_io_service::on_completion(win_iocp_operation* op,
-    DWORD last_error, DWORD bytes_transferred)
-{
-  // Flag that the operation is ready for invocation.
-  op->ready_ = 1;
-
-  // Store results in the OVERLAPPED structure.
-  op->Internal = asio::error::get_system_category();
-  op->Offset = last_error;
-  op->OffsetHigh = bytes_transferred;
-
-  // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle,
-        0, overlapped_contains_result, op))
-  {
-    // Out of resources. Put on completed queue instead.
-    mutex::scoped_lock lock(dispatch_mutex_);
-    completed_ops_.push(op);
-    ::InterlockedExchange(&dispatch_required_, 1);
-  }
-}
-
-void win_iocp_io_service::on_completion(win_iocp_operation* op,
-    const asio::error_code& ec, DWORD bytes_transferred)
-{
-  // Flag that the operation is ready for invocation.
-  op->ready_ = 1;
-
-  // Store results in the OVERLAPPED structure.
-  op->Internal = ec.category();
-  op->Offset = ec.value();
-  op->OffsetHigh = bytes_transferred;
-
-  // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle,
-        0, overlapped_contains_result, op))
-  {
-    // Out of resources. Put on completed queue instead.
-    mutex::scoped_lock lock(dispatch_mutex_);
-    completed_ops_.push(op);
-    ::InterlockedExchange(&dispatch_required_, 1);
-  }
-}
-
-size_t win_iocp_io_service::do_one(bool block, asio::error_code& ec)
-{
-  for (;;)
-  {
-    // Try to acquire responsibility for dispatching timers and completed ops.
-    if (::InterlockedCompareExchange(&dispatch_required_, 0, 1) == 1)
-    {
-      mutex::scoped_lock lock(dispatch_mutex_);
-
-      // Dispatch pending timers and operations.
-      op_queue<win_iocp_operation> ops;
-      ops.push(completed_ops_);
-      timer_queues_.get_ready_timers(ops);
-      post_deferred_completions(ops);
-      update_timeout();
-    }
-
-    // Get the next operation from the queue.
-    DWORD bytes_transferred = 0;
-    dword_ptr_t completion_key = 0;
-    LPOVERLAPPED overlapped = 0;
-    ::SetLastError(0);
-    BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
-        &completion_key, &overlapped, block ? gqcs_timeout : 0);
-    DWORD last_error = ::GetLastError();
-
-    if (overlapped)
-    {
-      win_iocp_operation* op = static_cast<win_iocp_operation*>(overlapped);
-      asio::error_code result_ec(last_error,
-          asio::error::get_system_category());
-
-      // We may have been passed the last_error and bytes_transferred in the
-      // OVERLAPPED structure itself.
-      if (completion_key == overlapped_contains_result)
-      {
-        result_ec = asio::error_code(static_cast<int>(op->Offset),
-            static_cast<asio::error_category>(op->Internal));
-        bytes_transferred = op->OffsetHigh;
-      }
-
-      // Otherwise ensure any result has been saved into the OVERLAPPED
-      // structure.
-      else
-      {
-        op->Internal = result_ec.category();
-        op->Offset = result_ec.value();
-        op->OffsetHigh = bytes_transferred;
-      }
-
-      // Dispatch the operation only if ready. The operation may not be ready
-      // if the initiating function (e.g. a call to WSARecv) has not yet
-      // returned. This is because the initiating function still wants access
-      // to the operation's OVERLAPPED structure.
-      if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
-      {
-        // Ensure the count of outstanding work is decremented on block exit.
-        work_finished_on_block_exit on_exit = { this };
-        (void)on_exit;
-
-        op->complete(*this, result_ec, bytes_transferred);
-        ec = asio::error_code();
-        return 1;
-      }
-    }
-    else if (!ok)
-    {
-      if (last_error != WAIT_TIMEOUT)
-      {
-        ec = asio::error_code(last_error,
-            asio::error::get_system_category());
-        return 0;
-      }
-
-      // If we're not polling we need to keep going until we get a real handler.
-      if (block)
-        continue;
-
-      ec = asio::error_code();
-      return 0;
-    }
-    else if (completion_key == wake_for_dispatch)
-    {
-      // We have been woken up to try to acquire responsibility for dispatching
-      // timers and completed operations.
-    }
-    else
-    {
-      // The stopped_ flag is always checked to ensure that any leftover
-      // interrupts from a previous run invocation are ignored.
-      if (::InterlockedExchangeAdd(&stopped_, 0) != 0)
-      {
-        // Wake up next thread that is blocked on GetQueuedCompletionStatus.
-        if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
-        {
-          last_error = ::GetLastError();
-          ec = asio::error_code(last_error,
-              asio::error::get_system_category());
-          return 0;
-        }
-
-        ec = asio::error_code();
-        return 0;
-      }
-    }
-  }
-}
-
-void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(dispatch_mutex_);
-
-  timer_queues_.insert(&queue);
-
-  if (!waitable_timer_.handle)
-  {
-    waitable_timer_.handle = ::CreateWaitableTimer(0, FALSE, 0);
-    if (waitable_timer_.handle == 0)
-    {
-      DWORD last_error = ::GetLastError();
-      asio::error_code ec(last_error,
-          asio::error::get_system_category());
-      asio::detail::throw_error(ec, "timer");
-    }
-
-    LARGE_INTEGER timeout;
-    timeout.QuadPart = -max_timeout_usec;
-    timeout.QuadPart *= 10;
-    ::SetWaitableTimer(waitable_timer_.handle,
-        &timeout, max_timeout_msec, 0, 0, FALSE);
-  }
-
-  if (!timer_thread_)
-  {
-    timer_thread_function thread_function = { this };
-    timer_thread_.reset(new thread(thread_function, 65536));
-  }
-}
-
-void win_iocp_io_service::do_remove_timer_queue(timer_queue_base& queue)
-{
-  mutex::scoped_lock lock(dispatch_mutex_);
-
-  timer_queues_.erase(&queue);
-}
-
-void win_iocp_io_service::update_timeout()
-{
-  if (timer_thread_)
-  {
-    // There's no point updating the waitable timer if the new timeout period
-    // exceeds the maximum timeout. In that case, we might as well wait for the
-    // existing period of the timer to expire.
-    long timeout_usec = timer_queues_.wait_duration_usec(max_timeout_usec);
-    if (timeout_usec < max_timeout_usec)
-    {
-      LARGE_INTEGER timeout;
-      timeout.QuadPart = -timeout_usec;
-      timeout.QuadPart *= 10;
-      ::SetWaitableTimer(waitable_timer_.handle,
-          &timeout, max_timeout_msec, 0, 0, FALSE);
-    }
-  }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP

ext/asio/asio/detail/impl/win_iocp_serial_port_service.ipp

@@ -1,180 +0,0 @@
-//
-// detail/impl/win_iocp_serial_port_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
-#define ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_SERIAL_PORT)
-
-#include <cstring>
-#include "asio/detail/win_iocp_serial_port_service.hpp"
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-win_iocp_serial_port_service::win_iocp_serial_port_service(
-    asio::io_service& io_service)
-  : handle_service_(io_service)
-{
-}
-
-void win_iocp_serial_port_service::shutdown_service()
-{
-}
-
-asio::error_code win_iocp_serial_port_service::open(
-    win_iocp_serial_port_service::implementation_type& impl,
-    const std::string& device, asio::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = asio::error::already_open;
-    return ec;
-  }
-
-  // For convenience, add a leading \\.\ sequence if not already present.
-  std::string name = (device[0] == '\\') ? device : "\\\\.\\" + device;
-
-  // Open a handle to the serial port.
-  ::HANDLE handle = ::CreateFileA(name.c_str(),
-      GENERIC_READ | GENERIC_WRITE, 0, 0,
-      OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
-  if (handle == INVALID_HANDLE_VALUE)
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  // Determine the initial serial port parameters.
-  using namespace std; // For memset.
-  ::DCB dcb;
-  memset(&dcb, 0, sizeof(DCB));
-  dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle, &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(handle);
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  // Set some default serial port parameters. This implementation does not
-  // support changing these, so they might as well be in a known state.
-  dcb.fBinary = TRUE; // Win32 only supports binary mode.
-  dcb.fDsrSensitivity = FALSE;
-  dcb.fNull = FALSE; // Do not ignore NULL characters.
-  dcb.fAbortOnError = FALSE; // Ignore serial framing errors.
-  if (!::SetCommState(handle, &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(handle);
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  // Set up timeouts so that the serial port will behave similarly to a
-  // network socket. Reads wait for at least one byte, then return with
-  // whatever they have. Writes return once everything is out the door.
-  ::COMMTIMEOUTS timeouts;
-  timeouts.ReadIntervalTimeout = 1;
-  timeouts.ReadTotalTimeoutMultiplier = 0;
-  timeouts.ReadTotalTimeoutConstant = 0;
-  timeouts.WriteTotalTimeoutMultiplier = 0;
-  timeouts.WriteTotalTimeoutConstant = 0;
-  if (!::SetCommTimeouts(handle, &timeouts))
-  {
-    DWORD last_error = ::GetLastError();
-    ::CloseHandle(handle);
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  // We're done. Take ownership of the serial port handle.
-  if (handle_service_.assign(impl, handle, ec))
-    ::CloseHandle(handle);
-  return ec;
-}
-
-asio::error_code win_iocp_serial_port_service::do_set_option(
-    win_iocp_serial_port_service::implementation_type& impl,
-    win_iocp_serial_port_service::store_function_type store,
-    const void* option, asio::error_code& ec)
-{
-  using namespace std; // For memcpy.
-
-  ::DCB dcb;
-  memset(&dcb, 0, sizeof(DCB));
-  dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native(impl), &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  if (store(option, dcb, ec))
-    return ec;
-
-  if (!::SetCommState(handle_service_.native(impl), &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  ec = asio::error_code();
-  return ec;
-}
-
-asio::error_code win_iocp_serial_port_service::do_get_option(
-    const win_iocp_serial_port_service::implementation_type& impl,
-    win_iocp_serial_port_service::load_function_type load,
-    void* option, asio::error_code& ec) const
-{
-  using namespace std; // For memset.
-
-  ::DCB dcb;
-  memset(&dcb, 0, sizeof(DCB));
-  dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native(impl), &dcb))
-  {
-    DWORD last_error = ::GetLastError();
-    ec = asio::error_code(last_error,
-        asio::error::get_system_category());
-    return ec;
-  }
-
-  return load(option, dcb, ec);
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_IOCP) && defined(ASIO_HAS_SERIAL_PORT)
-
-#endif // ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP