diff options
Diffstat (limited to 'boost/asio/windows/basic_random_access_handle.hpp')
| -rw-r--r-- | boost/asio/windows/basic_random_access_handle.hpp | 167 |
1 files changed, 109 insertions, 58 deletions
diff --git a/boost/asio/windows/basic_random_access_handle.hpp b/boost/asio/windows/basic_random_access_handle.hpp index 53765e1766..5f0d6d48c6 100644 --- a/boost/asio/windows/basic_random_access_handle.hpp +++ b/boost/asio/windows/basic_random_access_handle.hpp @@ -2,7 +2,7 @@ // windows/basic_random_access_handle.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) @@ -16,19 +16,11 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> - -#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) +#include <boost/asio/windows/basic_overlapped_handle.hpp> #if defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \ || defined(GENERATING_DOCUMENTATION) -#include <cstddef> -#include <boost/asio/detail/handler_type_requirements.hpp> -#include <boost/asio/detail/throw_error.hpp> -#include <boost/asio/error.hpp> -#include <boost/asio/windows/basic_handle.hpp> -#include <boost/asio/windows/random_access_handle_service.hpp> - #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -37,89 +29,136 @@ namespace windows { /// Provides random-access handle functionality. /** - * The windows::basic_random_access_handle class template provides asynchronous - * and blocking random-access handle functionality. + * The windows::basic_random_access_handle class provides asynchronous and + * blocking random-access handle functionality. * * @par Thread Safety * @e Distinct @e objects: Safe.@n * @e Shared @e objects: Unsafe. */ -template <typename RandomAccessHandleService = random_access_handle_service> +template <typename Executor = executor> class basic_random_access_handle - : public basic_handle<RandomAccessHandleService> + : public basic_overlapped_handle<Executor> { public: + /// The type of the executor associated with the object. + typedef Executor executor_type; + /// The native representation of a handle. - typedef typename RandomAccessHandleService::native_handle_type +#if defined(GENERATING_DOCUMENTATION) + typedef implementation_defined native_handle_type; +#else + typedef boost::asio::detail::win_iocp_handle_service::native_handle_type native_handle_type; +#endif - /// Construct a basic_random_access_handle without opening it. + /// Construct a random-access handle without opening it. + /** + * This constructor creates a random-access handle without opening it. + * + * @param ex The I/O executor that the random-access handle will use, by + * default, to dispatch handlers for any asynchronous operations performed on + * the random-access handle. + */ + explicit basic_random_access_handle(const executor_type& ex) + : basic_overlapped_handle<Executor>(ex) + { + } + + /// Construct a random-access handle without opening it. /** * This constructor creates a random-access handle without opening it. The - * handle needs to be opened before data can be written to or read from it. + * handle needs to be opened or assigned before data can be sent or received + * on it. * - * @param io_context The io_context object that the random-access handle will - * use to dispatch handlers for any asynchronous operations performed on the - * handle. + * @param context An execution context which provides the I/O executor that + * the random-access handle will use, by default, to dispatch handlers for any + * asynchronous operations performed on the random-access handle. */ - explicit basic_random_access_handle(boost::asio::io_context& io_context) - : basic_handle<RandomAccessHandleService>(io_context) + template <typename ExecutionContext> + explicit basic_random_access_handle(ExecutionContext& context, + typename enable_if< + is_convertible<ExecutionContext&, execution_context&>::value, + basic_random_access_handle + >::type* = 0) + : basic_overlapped_handle<Executor>(context) { } - /// Construct a basic_random_access_handle on an existing native handle. + /// Construct a random-access handle on an existing native handle. /** * This constructor creates a random-access handle object to hold an existing * native handle. * - * @param io_context The io_context object that the random-access handle will - * use to dispatch handlers for any asynchronous operations performed on the - * handle. + * @param ex The I/O executor that the random-access handle will use, by + * default, to dispatch handlers for any asynchronous operations performed on + * the random-access handle. * * @param handle The new underlying handle implementation. * * @throws boost::system::system_error Thrown on failure. */ - basic_random_access_handle(boost::asio::io_context& io_context, + basic_random_access_handle(const executor_type& ex, const native_handle_type& handle) - : basic_handle<RandomAccessHandleService>(io_context, handle) + : basic_overlapped_handle<Executor>(ex, handle) + { + } + + /// Construct a random-access handle on an existing native handle. + /** + * This constructor creates a random-access handle object to hold an existing + * native handle. + * + * @param context An execution context which provides the I/O executor that + * the random-access handle will use, by default, to dispatch handlers for any + * asynchronous operations performed on the random-access handle. + * + * @param handle The new underlying handle implementation. + * + * @throws boost::system::system_error Thrown on failure. + */ + template <typename ExecutionContext> + basic_random_access_handle(ExecutionContext& context, + const native_handle_type& handle, + typename enable_if< + is_convertible<ExecutionContext&, execution_context&>::value + >::type* = 0) + : basic_overlapped_handle<Executor>(context, handle) { } #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) - /// Move-construct a basic_random_access_handle from another. + /// Move-construct a random-access handle from another. /** * This constructor moves a random-access handle from one object to another. * - * @param other The other basic_random_access_handle object from which the + * @param other The other random-access handle object from which the * move will occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_random_access_handle(io_context&) + * constructed using the @c basic_random_access_handle(const executor_type&) * constructor. */ basic_random_access_handle(basic_random_access_handle&& other) - : basic_handle<RandomAccessHandleService>( - BOOST_ASIO_MOVE_CAST(basic_random_access_handle)(other)) + : basic_overlapped_handle<Executor>(std::move(other)) { } - /// Move-assign a basic_random_access_handle from another. + /// Move-assign a random-access handle from another. /** * This assignment operator moves a random-access handle from one object to * another. * - * @param other The other basic_random_access_handle object from which the + * @param other The other random-access handle object from which the * move will occur. * * @note Following the move, the moved-from object is in the same state as if - * constructed using the @c basic_random_access_handle(io_context&) + * constructed using the @c basic_random_access_handle(const executor_type&) * constructor. */ basic_random_access_handle& operator=(basic_random_access_handle&& other) { - basic_handle<RandomAccessHandleService>::operator=( - BOOST_ASIO_MOVE_CAST(basic_random_access_handle)(other)); + basic_overlapped_handle<Executor>::operator=(std::move(other)); return *this; } #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) @@ -158,8 +197,8 @@ public: const ConstBufferSequence& buffers) { boost::system::error_code ec; - std::size_t s = this->get_service().write_some_at( - this->get_implementation(), offset, buffers, ec); + std::size_t s = this->impl_.get_service().write_some_at( + this->impl_.get_implementation(), offset, buffers, ec); boost::asio::detail::throw_error(ec, "write_some_at"); return s; } @@ -186,8 +225,8 @@ public: std::size_t write_some_at(uint64_t offset, const ConstBufferSequence& buffers, boost::system::error_code& ec) { - return this->get_service().write_some_at( - this->get_implementation(), offset, buffers, ec); + return this->impl_.get_service().write_some_at( + this->impl_.get_implementation(), offset, buffers, ec); } /// Start an asynchronous write at the specified offset. @@ -210,9 +249,9 @@ public: * 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 - * 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(). * * @note The write operation may not transmit all of the data to the peer. * Consider using the @ref async_write_at function if you need to ensure that @@ -238,8 +277,15 @@ public: // not meet the documented type requirements for a WriteHandler. BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; - return this->get_service().async_write_some_at(this->get_implementation(), - offset, buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); + boost::asio::async_completion<WriteHandler, + void (boost::system::error_code, std::size_t)> init(handler); + + this->impl_.get_service().async_write_some_at( + this->impl_.get_implementation(), offset, + buffers, init.completion_handler, + this->impl_.get_implementation_executor()); + + return init.result.get(); } /// Read some data from the handle at the specified offset. @@ -277,8 +323,8 @@ public: const MutableBufferSequence& buffers) { boost::system::error_code ec; - std::size_t s = this->get_service().read_some_at( - this->get_implementation(), offset, buffers, ec); + std::size_t s = this->impl_.get_service().read_some_at( + this->impl_.get_implementation(), offset, buffers, ec); boost::asio::detail::throw_error(ec, "read_some_at"); return s; } @@ -306,8 +352,8 @@ public: std::size_t read_some_at(uint64_t offset, const MutableBufferSequence& buffers, boost::system::error_code& ec) { - return this->get_service().read_some_at( - this->get_implementation(), offset, buffers, ec); + return this->impl_.get_service().read_some_at( + this->impl_.get_implementation(), offset, buffers, ec); } /// Start an asynchronous read at the specified offset. @@ -330,9 +376,9 @@ public: * 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 - * 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(). * * @note The read operation may not read all of the requested number of bytes. * Consider using the @ref async_read_at function if you need to ensure that @@ -359,8 +405,15 @@ public: // not meet the documented type requirements for a ReadHandler. BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - return this->get_service().async_read_some_at(this->get_implementation(), - offset, buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); + boost::asio::async_completion<ReadHandler, + void (boost::system::error_code, std::size_t)> init(handler); + + this->impl_.get_service().async_read_some_at( + this->impl_.get_implementation(), offset, + buffers, init.completion_handler, + this->impl_.get_implementation_executor()); + + return init.result.get(); } }; @@ -373,6 +426,4 @@ public: #endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) // || defined(GENERATING_DOCUMENTATION) -#endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) - #endif // BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP |