diff options
Diffstat (limited to 'boost/asio/basic_seq_packet_socket.hpp')
| -rw-r--r-- | boost/asio/basic_seq_packet_socket.hpp | 360 |
1 files changed, 227 insertions, 133 deletions
diff --git a/boost/asio/basic_seq_packet_socket.hpp b/boost/asio/basic_seq_packet_socket.hpp index cc98656df3..7c3903ea59 100644 --- a/boost/asio/basic_seq_packet_socket.hpp +++ b/boost/asio/basic_seq_packet_socket.hpp @@ -2,7 +2,7 @@ // basic_seq_packet_socket.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2019 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) @@ -22,15 +22,20 @@ #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) -# include <boost/asio/seq_packet_socket_service.hpp> -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { +#if !defined(BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL) +#define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL + +// Forward declaration with defaulted arguments. +template <typename Protocol, typename Executor = executor> +class basic_seq_packet_socket; + +#endif // !defined(BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL) + /// Provides sequenced packet socket functionality. /** * The basic_seq_packet_socket class template provides asynchronous and blocking @@ -40,18 +45,28 @@ namespace asio { * @e Distinct @e objects: Safe.@n * @e Shared @e objects: Unsafe. */ -template <typename Protocol - BOOST_ASIO_SVC_TPARAM_DEF1(= seq_packet_socket_service<Protocol>)> +template <typename Protocol, typename Executor> class basic_seq_packet_socket - : public basic_socket<Protocol BOOST_ASIO_SVC_TARG> + : public basic_socket<Protocol, Executor> { public: + /// The type of the executor associated with the object. + typedef Executor executor_type; + + /// Rebinds the socket type to another executor. + template <typename Executor1> + struct rebind_executor + { + /// The socket type when rebound to the specified executor. + typedef basic_seq_packet_socket<Protocol, Executor1> other; + }; + /// The native representation of a socket. #if defined(GENERATING_DOCUMENTATION) typedef implementation_defined native_handle_type; #else - typedef typename basic_socket< - Protocol BOOST_ASIO_SVC_TARG>::native_handle_type native_handle_type; + typedef typename basic_socket<Protocol, + Executor>::native_handle_type native_handle_type; #endif /// The protocol type. @@ -66,12 +81,30 @@ public: * socket needs to be opened and then connected or accepted before data can * be sent or received on it. * - * @param io_context The io_context object that the sequenced packet socket - * will use to dispatch handlers for any asynchronous operations performed on - * the socket. + * @param ex The I/O executor that the socket will use, by default, to + * dispatch handlers for any asynchronous operations performed on the socket. + */ + explicit basic_seq_packet_socket(const executor_type& ex) + : basic_socket<Protocol, Executor>(ex) + { + } + + /// Construct a basic_seq_packet_socket without opening it. + /** + * This constructor creates a sequenced packet 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 context An execution context which provides the I/O executor that + * the socket will use, by default, to dispatch handlers for any asynchronous + * operations performed on the socket. */ - explicit basic_seq_packet_socket(boost::asio::io_context& io_context) - : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(io_context) + template <typename ExecutionContext> + explicit basic_seq_packet_socket(ExecutionContext& context, + typename enable_if< + is_convertible<ExecutionContext&, execution_context&>::value + >::type* = 0) + : basic_socket<Protocol, Executor>(context) { } @@ -81,17 +114,40 @@ public: * needs to be connected or accepted before data can be sent or received on * it. * - * @param io_context The io_context object that the sequenced packet socket - * will use to dispatch handlers for any asynchronous operations performed on - * the socket. + * @param ex The I/O executor that the socket will use, by default, to + * dispatch handlers for any asynchronous operations performed on the socket. * * @param protocol An object specifying protocol parameters to be used. * * @throws boost::system::system_error Thrown on failure. */ - basic_seq_packet_socket(boost::asio::io_context& io_context, + basic_seq_packet_socket(const executor_type& ex, const protocol_type& protocol) - : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(io_context, protocol) + : basic_socket<Protocol, Executor>(ex, protocol) + { + } + + /// Construct and open a basic_seq_packet_socket. + /** + * This constructor creates and opens a sequenced_packet socket. The socket + * needs to be connected or accepted before data can be sent or received on + * it. + * + * @param context An execution context which provides the I/O executor that + * the socket will use, by default, to dispatch handlers for any asynchronous + * operations performed on the socket. + * + * @param protocol An object specifying protocol parameters to be used. + * + * @throws boost::system::system_error Thrown on failure. + */ + template <typename ExecutionContext> + basic_seq_packet_socket(ExecutionContext& context, + const protocol_type& protocol, + typename enable_if< + is_convertible<ExecutionContext&, execution_context&>::value + >::type* = 0) + : basic_socket<Protocol, Executor>(context, protocol) { } @@ -102,18 +158,43 @@ public: * it bound to the specified endpoint on the local machine. The protocol used * is the protocol associated with the given endpoint. * - * @param io_context The io_context object that the sequenced packet socket - * will use to dispatch handlers for any asynchronous operations performed on - * the socket. + * @param ex The I/O executor that the socket will use, by default, to + * dispatch handlers for any asynchronous operations performed on the socket. * * @param endpoint An endpoint on the local machine to which the sequenced * packet socket will be bound. * * @throws boost::system::system_error Thrown on failure. */ - basic_seq_packet_socket(boost::asio::io_context& io_context, + basic_seq_packet_socket(const executor_type& ex, const endpoint_type& endpoint) - : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(io_context, endpoint) + : basic_socket<Protocol, Executor>(ex, endpoint) + { + } + + /// Construct a basic_seq_packet_socket, opening it and binding it to the + /// given local endpoint. + /** + * This constructor creates a sequenced packet 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 context An execution context which provides the I/O executor that + * the socket will use, by default, to dispatch handlers for any asynchronous + * operations performed on the socket. + * + * @param endpoint An endpoint on the local machine to which the sequenced + * packet socket will be bound. + * + * @throws boost::system::system_error Thrown on failure. + */ + template <typename ExecutionContext> + basic_seq_packet_socket(ExecutionContext& context, + const endpoint_type& endpoint, + typename enable_if< + is_convertible<ExecutionContext&, execution_context&>::value + >::type* = 0) + : basic_socket<Protocol, Executor>(context, endpoint) { } @@ -122,9 +203,8 @@ public: * This constructor creates a sequenced packet socket object to hold an * existing native socket. * - * @param io_context The io_context object that the sequenced packet socket - * will use to dispatch handlers for any asynchronous operations performed on - * the socket. + * @param ex The I/O executor that the socket will use, by default, to + * dispatch handlers for any asynchronous operations performed on the socket. * * @param protocol An object specifying protocol parameters to be used. * @@ -132,10 +212,34 @@ public: * * @throws boost::system::system_error Thrown on failure. */ - basic_seq_packet_socket(boost::asio::io_context& io_context, + basic_seq_packet_socket(const executor_type& ex, const protocol_type& protocol, const native_handle_type& native_socket) - : basic_socket<Protocol BOOST_ASIO_SVC_TARG>( - io_context, protocol, native_socket) + : basic_socket<Protocol, Executor>(ex, protocol, native_socket) + { + } + + /// Construct a basic_seq_packet_socket on an existing native socket. + /** + * This constructor creates a sequenced packet socket object to hold an + * existing native socket. + * + * @param context An execution context which provides the I/O executor that + * the socket will use, by default, 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 boost::system::system_error Thrown on failure. + */ + template <typename ExecutionContext> + basic_seq_packet_socket(ExecutionContext& context, + const protocol_type& protocol, const native_handle_type& native_socket, + typename enable_if< + is_convertible<ExecutionContext&, execution_context&>::value + >::type* = 0) + : basic_socket<Protocol, Executor>(context, protocol, native_socket) { } @@ -149,10 +253,11 @@ public: * will occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_seq_packet_socket(io_context&) constructor. + * constructed using the @c basic_seq_packet_socket(const executor_type&) + * constructor. */ basic_seq_packet_socket(basic_seq_packet_socket&& other) - : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(std::move(other)) + : basic_socket<Protocol, Executor>(std::move(other)) { } @@ -165,11 +270,12 @@ public: * will occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_seq_packet_socket(io_context&) constructor. + * constructed using the @c basic_seq_packet_socket(const executor_type&) + * constructor. */ basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other) { - basic_socket<Protocol BOOST_ASIO_SVC_TARG>::operator=(std::move(other)); + basic_socket<Protocol, Executor>::operator=(std::move(other)); return *this; } @@ -183,13 +289,16 @@ public: * will occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_seq_packet_socket(io_context&) constructor. + * constructed using the @c basic_seq_packet_socket(const executor_type&) + * constructor. */ - template <typename Protocol1 BOOST_ASIO_SVC_TPARAM1> - basic_seq_packet_socket( - basic_seq_packet_socket<Protocol1 BOOST_ASIO_SVC_TARG1>&& other, - typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0) - : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(std::move(other)) + template <typename Protocol1, typename Executor1> + basic_seq_packet_socket(basic_seq_packet_socket<Protocol1, Executor1>&& other, + typename enable_if< + is_convertible<Protocol1, Protocol>::value + && is_convertible<Executor1, Executor>::value + >::type* = 0) + : basic_socket<Protocol, Executor>(std::move(other)) { } @@ -203,14 +312,17 @@ public: * will occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_seq_packet_socket(io_context&) constructor. + * constructed using the @c basic_seq_packet_socket(const executor_type&) + * constructor. */ - template <typename Protocol1 BOOST_ASIO_SVC_TPARAM1> - typename enable_if<is_convertible<Protocol1, Protocol>::value, - basic_seq_packet_socket>::type& operator=( - basic_seq_packet_socket<Protocol1 BOOST_ASIO_SVC_TARG1>&& other) + template <typename Protocol1, typename Executor1> + typename enable_if< + is_convertible<Protocol1, Protocol>::value + && is_convertible<Executor1, Executor>::value, + basic_seq_packet_socket& + >::type operator=(basic_seq_packet_socket<Protocol1, Executor1>&& other) { - basic_socket<Protocol BOOST_ASIO_SVC_TARG>::operator=(std::move(other)); + basic_socket<Protocol, Executor>::operator=(std::move(other)); return *this; } #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) @@ -252,8 +364,8 @@ public: socket_base::message_flags flags) { boost::system::error_code ec; - std::size_t s = this->get_service().send( - this->get_implementation(), buffers, flags, ec); + std::size_t s = this->impl_.get_service().send( + this->impl_.get_implementation(), buffers, flags, ec); boost::asio::detail::throw_error(ec, "send"); return s; } @@ -280,8 +392,8 @@ public: std::size_t send(const ConstBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { - return this->get_service().send( - this->get_implementation(), buffers, flags, ec); + return this->impl_.get_service().send( + this->impl_.get_implementation(), buffers, flags, ec); } /// Start an asynchronous send. @@ -304,9 +416,9 @@ public: * 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 - * boost::asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using boost::asio::post(). * * @par Example * To send a single data buffer use the @ref buffer function as follows: @@ -324,22 +436,9 @@ public: socket_base::message_flags flags, BOOST_ASIO_MOVE_ARG(WriteHandler) handler) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a WriteHandler. - BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; - -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_send(this->get_implementation(), - buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); -#else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - async_completion<WriteHandler, - void (boost::system::error_code, std::size_t)> init(handler); - - this->get_service().async_send(this->get_implementation(), - buffers, flags, init.completion_handler); - - return init.result.get(); -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) + return async_initiate<WriteHandler, + void (boost::system::error_code, std::size_t)>( + initiate_async_send(), handler, this, buffers, flags); } /// Receive some data on the socket. @@ -376,13 +475,8 @@ public: socket_base::message_flags& out_flags) { boost::system::error_code ec; -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - std::size_t s = this->get_service().receive( - this->get_implementation(), buffers, 0, out_flags, ec); -#else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - std::size_t s = this->get_service().receive_with_flags( - this->get_implementation(), buffers, 0, out_flags, ec); -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) + std::size_t s = this->impl_.get_service().receive_with_flags( + this->impl_.get_implementation(), buffers, 0, out_flags, ec); boost::asio::detail::throw_error(ec, "receive"); return s; } @@ -428,13 +522,8 @@ public: socket_base::message_flags& out_flags) { boost::system::error_code ec; -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - std::size_t s = this->get_service().receive( - this->get_implementation(), buffers, in_flags, out_flags, ec); -#else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - std::size_t s = this->get_service().receive_with_flags( - this->get_implementation(), buffers, in_flags, out_flags, ec); -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) + std::size_t s = this->impl_.get_service().receive_with_flags( + this->impl_.get_implementation(), buffers, in_flags, out_flags, ec); boost::asio::detail::throw_error(ec, "receive"); return s; } @@ -467,13 +556,8 @@ public: socket_base::message_flags in_flags, socket_base::message_flags& out_flags, boost::system::error_code& ec) { -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - return this->get_service().receive(this->get_implementation(), - buffers, in_flags, out_flags, ec); -#else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - return this->get_service().receive_with_flags(this->get_implementation(), - buffers, in_flags, out_flags, ec); -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) + return this->impl_.get_service().receive_with_flags( + this->impl_.get_implementation(), buffers, in_flags, out_flags, ec); } /// Start an asynchronous receive. @@ -500,9 +584,9 @@ public: * 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 - * boost::asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using boost::asio::post(). * * @par Example * To receive into a single data buffer use the @ref buffer function as @@ -521,24 +605,10 @@ public: socket_base::message_flags& out_flags, BOOST_ASIO_MOVE_ARG(ReadHandler) handler) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a ReadHandler. - BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_receive( - this->get_implementation(), buffers, 0, out_flags, - BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); -#else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - async_completion<ReadHandler, - void (boost::system::error_code, std::size_t)> init(handler); - - this->get_service().async_receive_with_flags( - this->get_implementation(), buffers, 0, out_flags, - init.completion_handler); - - return init.result.get(); -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) + return async_initiate<ReadHandler, + void (boost::system::error_code, std::size_t)>( + initiate_async_receive_with_flags(), handler, this, + buffers, socket_base::message_flags(0), &out_flags); } /// Start an asynchronous receive. @@ -567,9 +637,9 @@ public: * 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 - * boost::asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using boost::asio::post(). * * @par Example * To receive into a single data buffer use the @ref buffer function as @@ -591,25 +661,49 @@ public: socket_base::message_flags& out_flags, BOOST_ASIO_MOVE_ARG(ReadHandler) handler) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a ReadHandler. - BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - return this->get_service().async_receive( - this->get_implementation(), buffers, in_flags, out_flags, - BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); -#else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - async_completion<ReadHandler, - void (boost::system::error_code, std::size_t)> init(handler); - - this->get_service().async_receive_with_flags( - this->get_implementation(), buffers, in_flags, out_flags, - init.completion_handler); - - return init.result.get(); -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) + return async_initiate<ReadHandler, + void (boost::system::error_code, std::size_t)>( + initiate_async_receive_with_flags(), handler, + this, buffers, in_flags, &out_flags); } + +private: + struct initiate_async_send + { + template <typename WriteHandler, typename ConstBufferSequence> + void operator()(BOOST_ASIO_MOVE_ARG(WriteHandler) handler, + basic_seq_packet_socket* self, const ConstBufferSequence& buffers, + socket_base::message_flags flags) const + { + // If you get an error on the following line it means that your handler + // does not meet the documented type requirements for a WriteHandler. + BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; + + detail::non_const_lvalue<WriteHandler> handler2(handler); + self->impl_.get_service().async_send( + self->impl_.get_implementation(), buffers, flags, + handler2.value, self->impl_.get_implementation_executor()); + } + }; + + struct initiate_async_receive_with_flags + { + template <typename ReadHandler, typename MutableBufferSequence> + void operator()(BOOST_ASIO_MOVE_ARG(ReadHandler) handler, + basic_seq_packet_socket* self, const MutableBufferSequence& buffers, + socket_base::message_flags in_flags, + socket_base::message_flags* out_flags) const + { + // If you get an error on the following line it means that your handler + // does not meet the documented type requirements for a ReadHandler. + BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; + + detail::non_const_lvalue<ReadHandler> handler2(handler); + self->impl_.get_service().async_receive_with_flags( + self->impl_.get_implementation(), buffers, in_flags, *out_flags, + handler2.value, self->impl_.get_implementation_executor()); + } + }; }; } // namespace asio |