diff options
Diffstat (limited to '3rdparty/asio/include/asio/impl/read_at.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/impl/read_at.hpp | 427 |
1 files changed, 260 insertions, 167 deletions
diff --git a/3rdparty/asio/include/asio/impl/read_at.hpp b/3rdparty/asio/include/asio/impl/read_at.hpp index 273312f139f..7d37c4ddfa4 100644 --- a/3rdparty/asio/include/asio/impl/read_at.hpp +++ b/3rdparty/asio/include/asio/impl/read_at.hpp @@ -2,7 +2,7 @@ // impl/read_at.hpp // ~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2021 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,11 +16,11 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <algorithm> -#include "asio/associated_allocator.hpp" -#include "asio/associated_executor.hpp" +#include "asio/associator.hpp" #include "asio/buffer.hpp" #include "asio/completion_condition.hpp" #include "asio/detail/array_fwd.hpp" +#include "asio/detail/base_from_cancellation_state.hpp" #include "asio/detail/base_from_completion_cond.hpp" #include "asio/detail/bind_handler.hpp" #include "asio/detail/consuming_buffers.hpp" @@ -28,7 +28,9 @@ #include "asio/detail/handler_alloc_helpers.hpp" #include "asio/detail/handler_cont_helpers.hpp" #include "asio/detail/handler_invoke_helpers.hpp" +#include "asio/detail/handler_tracking.hpp" #include "asio/detail/handler_type_requirements.hpp" +#include "asio/detail/non_const_lvalue.hpp" #include "asio/detail/throw_error.hpp" #include "asio/error.hpp" @@ -59,7 +61,7 @@ namespace detail else break; } - return tmp.total_consumed();; + return tmp.total_consumed(); } } // namespace detail @@ -70,7 +72,8 @@ std::size_t read_at(SyncRandomAccessReadDevice& d, CompletionCondition completion_condition, asio::error_code& ec) { return detail::read_at_buffer_sequence(d, offset, buffers, - asio::buffer_sequence_begin(buffers), completion_condition, ec); + asio::buffer_sequence_begin(buffers), + ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec); } template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence> @@ -99,8 +102,8 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d, CompletionCondition completion_condition) { asio::error_code ec; - std::size_t bytes_transferred = read_at( - d, offset, buffers, completion_condition, ec); + std::size_t bytes_transferred = read_at(d, offset, buffers, + ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec); asio::detail::throw_error(ec, "read_at"); return bytes_transferred; } @@ -158,8 +161,8 @@ inline std::size_t read_at(SyncRandomAccessReadDevice& d, CompletionCondition completion_condition) { asio::error_code ec; - std::size_t bytes_transferred = read_at( - d, offset, b, completion_condition, ec); + std::size_t bytes_transferred = read_at(d, offset, b, + ASIO_MOVE_CAST(CompletionCondition)(completion_condition), ec); asio::detail::throw_error(ec, "read_at"); return bytes_transferred; } @@ -173,14 +176,16 @@ namespace detail typename MutableBufferSequence, typename MutableBufferIterator, typename CompletionCondition, typename ReadHandler> class read_at_op - : detail::base_from_completion_cond<CompletionCondition> + : public base_from_cancellation_state<ReadHandler>, + base_from_completion_cond<CompletionCondition> { public: read_at_op(AsyncRandomAccessReadDevice& device, uint64_t offset, const MutableBufferSequence& buffers, - CompletionCondition completion_condition, ReadHandler& handler) - : detail::base_from_completion_cond< - CompletionCondition>(completion_condition), + CompletionCondition& completion_condition, ReadHandler& handler) + : base_from_cancellation_state<ReadHandler>( + handler, enable_partial_cancellation()), + base_from_completion_cond<CompletionCondition>(completion_condition), device_(device), offset_(offset), buffers_(buffers), @@ -191,7 +196,8 @@ namespace detail #if defined(ASIO_HAS_MOVE) read_at_op(const read_at_op& other) - : detail::base_from_completion_cond<CompletionCondition>(other), + : base_from_cancellation_state<ReadHandler>(other), + base_from_completion_cond<CompletionCondition>(other), device_(other.device_), offset_(other.offset_), buffers_(other.buffers_), @@ -201,17 +207,22 @@ namespace detail } read_at_op(read_at_op&& other) - : detail::base_from_completion_cond<CompletionCondition>(other), + : base_from_cancellation_state<ReadHandler>( + ASIO_MOVE_CAST(base_from_cancellation_state< + ReadHandler>)(other)), + base_from_completion_cond<CompletionCondition>( + ASIO_MOVE_CAST(base_from_completion_cond< + CompletionCondition>)(other)), device_(other.device_), offset_(other.offset_), - buffers_(other.buffers_), + buffers_(ASIO_MOVE_CAST(buffers_type)(other.buffers_)), start_(other.start_), handler_(ASIO_MOVE_CAST(ReadHandler)(other.handler_)) { } #endif // defined(ASIO_HAS_MOVE) - void operator()(const asio::error_code& ec, + void operator()(asio::error_code ec, std::size_t bytes_transferred, int start = 0) { std::size_t max_size; @@ -219,27 +230,41 @@ namespace detail { case 1: max_size = this->check_for_completion(ec, buffers_.total_consumed()); - do + for (;;) { - device_.async_read_some_at( - offset_ + buffers_.total_consumed(), buffers_.prepare(max_size), - ASIO_MOVE_CAST(read_at_op)(*this)); + { + ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read_at")); + device_.async_read_some_at( + offset_ + buffers_.total_consumed(), buffers_.prepare(max_size), + ASIO_MOVE_CAST(read_at_op)(*this)); + } return; default: buffers_.consume(bytes_transferred); if ((!ec && bytes_transferred == 0) || buffers_.empty()) break; max_size = this->check_for_completion(ec, buffers_.total_consumed()); - } while (max_size > 0); + if (max_size == 0) + break; + if (this->cancelled() != cancellation_type::none) + { + ec = asio::error::operation_aborted; + break; + } + } - handler_(ec, buffers_.total_consumed()); + ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)( + static_cast<const asio::error_code&>(ec), + static_cast<const std::size_t&>(buffers_.total_consumed())); } } //private: + typedef asio::detail::consuming_buffers<mutable_buffer, + MutableBufferSequence, MutableBufferIterator> buffers_type; + AsyncRandomAccessReadDevice& device_; uint64_t offset_; - asio::detail::consuming_buffers<mutable_buffer, - MutableBufferSequence, MutableBufferIterator> buffers_; + buffers_type buffers_; int start_; ReadHandler handler_; }; @@ -247,23 +272,33 @@ namespace detail template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename MutableBufferIterator, typename CompletionCondition, typename ReadHandler> - inline void* asio_handler_allocate(std::size_t size, + inline asio_handler_allocate_is_deprecated + asio_handler_allocate(std::size_t size, read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler) { +#if defined(ASIO_NO_DEPRECATED) + asio_handler_alloc_helpers::allocate(size, this_handler->handler_); + return asio_handler_allocate_is_no_longer_used(); +#else // defined(ASIO_NO_DEPRECATED) return asio_handler_alloc_helpers::allocate( size, this_handler->handler_); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename MutableBufferIterator, typename CompletionCondition, typename ReadHandler> - inline void asio_handler_deallocate(void* pointer, std::size_t size, + inline asio_handler_deallocate_is_deprecated + asio_handler_deallocate(void* pointer, std::size_t size, read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler) { asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_deallocate_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename AsyncRandomAccessReadDevice, @@ -281,23 +316,31 @@ namespace detail template <typename Function, typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename MutableBufferIterator, typename CompletionCondition, typename ReadHandler> - inline void asio_handler_invoke(Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(Function& function, read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler) { asio_handler_invoke_helpers::invoke( function, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_invoke_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename Function, typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename MutableBufferIterator, typename CompletionCondition, typename ReadHandler> - inline void asio_handler_invoke(const Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(const Function& function, read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler) { asio_handler_invoke_helpers::invoke( function, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_invoke_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename AsyncRandomAccessReadDevice, @@ -305,7 +348,7 @@ namespace detail typename CompletionCondition, typename ReadHandler> inline void start_read_at_buffer_sequence_op(AsyncRandomAccessReadDevice& d, uint64_t offset, const MutableBufferSequence& buffers, - const MutableBufferIterator&, CompletionCondition completion_condition, + const MutableBufferIterator&, CompletionCondition& completion_condition, ReadHandler& handler) { detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, @@ -313,95 +356,103 @@ namespace detail d, offset, buffers, completion_condition, handler)( asio::error_code(), 0, 1); } -} // namespace detail -#if !defined(GENERATING_DOCUMENTATION) + template <typename AsyncRandomAccessReadDevice> + class initiate_async_read_at_buffer_sequence + { + public: + typedef typename AsyncRandomAccessReadDevice::executor_type executor_type; -template <typename AsyncRandomAccessReadDevice, - typename MutableBufferSequence, typename MutableBufferIterator, - typename CompletionCondition, typename ReadHandler, typename Allocator> -struct associated_allocator< - detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, - MutableBufferIterator, CompletionCondition, ReadHandler>, - Allocator> -{ - typedef typename associated_allocator<ReadHandler, Allocator>::type type; + explicit initiate_async_read_at_buffer_sequence( + AsyncRandomAccessReadDevice& device) + : device_(device) + { + } - static type get( - const detail::read_at_op<AsyncRandomAccessReadDevice, - MutableBufferSequence, MutableBufferIterator, - CompletionCondition, ReadHandler>& h, - const Allocator& a = Allocator()) ASIO_NOEXCEPT - { - return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a); - } -}; + executor_type get_executor() const ASIO_NOEXCEPT + { + return device_.get_executor(); + } -template <typename AsyncRandomAccessReadDevice, - typename MutableBufferSequence, typename MutableBufferIterator, - typename CompletionCondition, typename ReadHandler, typename Executor> -struct associated_executor< + template <typename ReadHandler, typename MutableBufferSequence, + typename CompletionCondition> + void operator()(ASIO_MOVE_ARG(ReadHandler) handler, + uint64_t offset, const MutableBufferSequence& buffers, + ASIO_MOVE_ARG(CompletionCondition) completion_cond) 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. + ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; + + non_const_lvalue<ReadHandler> handler2(handler); + non_const_lvalue<CompletionCondition> completion_cond2(completion_cond); + start_read_at_buffer_sequence_op(device_, offset, buffers, + asio::buffer_sequence_begin(buffers), + completion_cond2.value, handler2.value); + } + + private: + AsyncRandomAccessReadDevice& device_; + }; +} // namespace detail + +#if !defined(GENERATING_DOCUMENTATION) + +template <template <typename, typename> class Associator, + typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, + typename MutableBufferIterator, typename CompletionCondition, + typename ReadHandler, typename DefaultCandidate> +struct associator<Associator, detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence, - MutableBufferIterator, CompletionCondition, ReadHandler>, - Executor> + MutableBufferIterator, CompletionCondition, ReadHandler>, + DefaultCandidate> + : Associator<ReadHandler, DefaultCandidate> { - typedef typename associated_executor<ReadHandler, Executor>::type type; - - static type get( + static typename Associator<ReadHandler, DefaultCandidate>::type get( const detail::read_at_op<AsyncRandomAccessReadDevice, - MutableBufferSequence, MutableBufferIterator, - CompletionCondition, ReadHandler>& h, - const Executor& ex = Executor()) ASIO_NOEXCEPT + MutableBufferSequence, MutableBufferIterator, + CompletionCondition, ReadHandler>& h, + const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT { - return associated_executor<ReadHandler, Executor>::get(h.handler_, ex); + return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c); } }; #endif // !defined(GENERATING_DOCUMENTATION) -template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, - typename CompletionCondition, typename ReadHandler> -inline ASIO_INITFN_RESULT_TYPE(ReadHandler, +template <typename AsyncRandomAccessReadDevice, + typename MutableBufferSequence, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) ReadHandler> +inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (asio::error_code, std::size_t)) async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset, const MutableBufferSequence& buffers, CompletionCondition completion_condition, 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. - ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - - async_completion<ReadHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::start_read_at_buffer_sequence_op(d, offset, buffers, - asio::buffer_sequence_begin(buffers), completion_condition, - init.completion_handler); - - return init.result.get(); + return async_initiate<ReadHandler, + void (asio::error_code, std::size_t)>( + detail::initiate_async_read_at_buffer_sequence< + AsyncRandomAccessReadDevice>(d), + handler, offset, buffers, + ASIO_MOVE_CAST(CompletionCondition)(completion_condition)); } template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, - typename ReadHandler> -inline ASIO_INITFN_RESULT_TYPE(ReadHandler, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) ReadHandler> +inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (asio::error_code, std::size_t)) async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset, const MutableBufferSequence& buffers, 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. - ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - - async_completion<ReadHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::start_read_at_buffer_sequence_op(d, offset, buffers, - asio::buffer_sequence_begin(buffers), transfer_all(), - init.completion_handler); - - return init.result.get(); + return async_initiate<ReadHandler, + void (asio::error_code, std::size_t)>( + detail::initiate_async_read_at_buffer_sequence< + AsyncRandomAccessReadDevice>(d), + handler, offset, buffers, transfer_all()); } #if !defined(ASIO_NO_EXTENSIONS) @@ -412,14 +463,16 @@ namespace detail template <typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> class read_at_streambuf_op - : detail::base_from_completion_cond<CompletionCondition> + : public base_from_cancellation_state<ReadHandler>, + base_from_completion_cond<CompletionCondition> { public: read_at_streambuf_op(AsyncRandomAccessReadDevice& device, uint64_t offset, basic_streambuf<Allocator>& streambuf, - CompletionCondition completion_condition, ReadHandler& handler) - : detail::base_from_completion_cond< - CompletionCondition>(completion_condition), + CompletionCondition& completion_condition, ReadHandler& handler) + : base_from_cancellation_state<ReadHandler>( + handler, enable_partial_cancellation()), + base_from_completion_cond<CompletionCondition>(completion_condition), device_(device), offset_(offset), streambuf_(streambuf), @@ -431,7 +484,8 @@ namespace detail #if defined(ASIO_HAS_MOVE) read_at_streambuf_op(const read_at_streambuf_op& other) - : detail::base_from_completion_cond<CompletionCondition>(other), + : base_from_cancellation_state<ReadHandler>(other), + base_from_completion_cond<CompletionCondition>(other), device_(other.device_), offset_(other.offset_), streambuf_(other.streambuf_), @@ -442,7 +496,12 @@ namespace detail } read_at_streambuf_op(read_at_streambuf_op&& other) - : detail::base_from_completion_cond<CompletionCondition>(other), + : base_from_cancellation_state<ReadHandler>( + ASIO_MOVE_CAST(base_from_cancellation_state< + ReadHandler>)(other)), + base_from_completion_cond<CompletionCondition>( + ASIO_MOVE_CAST(base_from_completion_cond< + CompletionCondition>)(other)), device_(other.device_), offset_(other.offset_), streambuf_(other.streambuf_), @@ -453,7 +512,7 @@ namespace detail } #endif // defined(ASIO_HAS_MOVE) - void operator()(const asio::error_code& ec, + void operator()(asio::error_code ec, std::size_t bytes_transferred, int start = 0) { std::size_t max_size, bytes_available; @@ -464,9 +523,12 @@ namespace detail bytes_available = read_size_helper(streambuf_, max_size); for (;;) { - device_.async_read_some_at(offset_ + total_transferred_, - streambuf_.prepare(bytes_available), - ASIO_MOVE_CAST(read_at_streambuf_op)(*this)); + { + ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_read_at")); + device_.async_read_some_at(offset_ + total_transferred_, + streambuf_.prepare(bytes_available), + ASIO_MOVE_CAST(read_at_streambuf_op)(*this)); + } return; default: total_transferred_ += bytes_transferred; streambuf_.commit(bytes_transferred); @@ -474,9 +536,16 @@ namespace detail bytes_available = read_size_helper(streambuf_, max_size); if ((!ec && bytes_transferred == 0) || bytes_available == 0) break; + if (this->cancelled() != cancellation_type::none) + { + ec = asio::error::operation_aborted; + break; + } } - handler_(ec, static_cast<const std::size_t&>(total_transferred_)); + ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)( + static_cast<const asio::error_code&>(ec), + static_cast<const std::size_t&>(total_transferred_)); } } @@ -491,22 +560,32 @@ namespace detail template <typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> - inline void* asio_handler_allocate(std::size_t size, + inline asio_handler_allocate_is_deprecated + asio_handler_allocate(std::size_t size, read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, CompletionCondition, ReadHandler>* this_handler) { +#if defined(ASIO_NO_DEPRECATED) + asio_handler_alloc_helpers::allocate(size, this_handler->handler_); + return asio_handler_allocate_is_no_longer_used(); +#else // defined(ASIO_NO_DEPRECATED) return asio_handler_alloc_helpers::allocate( size, this_handler->handler_); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> - inline void asio_handler_deallocate(void* pointer, std::size_t size, + inline asio_handler_deallocate_is_deprecated + asio_handler_deallocate(void* pointer, std::size_t size, read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, CompletionCondition, ReadHandler>* this_handler) { asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_deallocate_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename AsyncRandomAccessReadDevice, typename Allocator, @@ -522,112 +601,126 @@ namespace detail template <typename Function, typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> - inline void asio_handler_invoke(Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(Function& function, read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, CompletionCondition, ReadHandler>* this_handler) { asio_handler_invoke_helpers::invoke( function, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_invoke_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) } template <typename Function, typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> - inline void asio_handler_invoke(const Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(const Function& function, read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, CompletionCondition, ReadHandler>* this_handler) { asio_handler_invoke_helpers::invoke( function, this_handler->handler_); +#if defined(ASIO_NO_DEPRECATED) + return asio_handler_invoke_is_no_longer_used(); +#endif // defined(ASIO_NO_DEPRECATED) } -} // namespace detail -#if !defined(GENERATING_DOCUMENTATION) + template <typename AsyncRandomAccessReadDevice> + class initiate_async_read_at_streambuf + { + public: + typedef typename AsyncRandomAccessReadDevice::executor_type executor_type; -template <typename AsyncRandomAccessReadDevice, typename Allocator, - typename CompletionCondition, typename ReadHandler, typename Allocator1> -struct associated_allocator< - detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, - Allocator, CompletionCondition, ReadHandler>, - Allocator1> -{ - typedef typename associated_allocator<ReadHandler, Allocator1>::type type; + explicit initiate_async_read_at_streambuf( + AsyncRandomAccessReadDevice& device) + : device_(device) + { + } - static type get( - const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, - Allocator, CompletionCondition, ReadHandler>& h, - const Allocator1& a = Allocator1()) ASIO_NOEXCEPT - { - return associated_allocator<ReadHandler, Allocator1>::get(h.handler_, a); - } -}; + executor_type get_executor() const ASIO_NOEXCEPT + { + return device_.get_executor(); + } + + template <typename ReadHandler, + typename Allocator, typename CompletionCondition> + void operator()(ASIO_MOVE_ARG(ReadHandler) handler, + uint64_t offset, basic_streambuf<Allocator>* b, + ASIO_MOVE_ARG(CompletionCondition) completion_cond) 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. + ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; -template <typename AsyncRandomAccessReadDevice, typename Executor, - typename CompletionCondition, typename ReadHandler, typename Executor1> -struct associated_executor< + non_const_lvalue<ReadHandler> handler2(handler); + non_const_lvalue<CompletionCondition> completion_cond2(completion_cond); + read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, + CompletionCondition, typename decay<ReadHandler>::type>( + device_, offset, *b, completion_cond2.value, handler2.value)( + asio::error_code(), 0, 1); + } + + private: + AsyncRandomAccessReadDevice& device_; + }; +} // namespace detail + +#if !defined(GENERATING_DOCUMENTATION) + +template <template <typename, typename> class Associator, + typename AsyncRandomAccessReadDevice, typename Executor, + typename CompletionCondition, typename ReadHandler, + typename DefaultCandidate> +struct associator<Associator, detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Executor, CompletionCondition, ReadHandler>, - Executor1> + DefaultCandidate> + : Associator<ReadHandler, DefaultCandidate> { - typedef typename associated_executor<ReadHandler, Executor1>::type type; - - static type get( + static typename Associator<ReadHandler, DefaultCandidate>::type get( const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Executor, CompletionCondition, ReadHandler>& h, - const Executor1& ex = Executor1()) ASIO_NOEXCEPT + const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT { - return associated_executor<ReadHandler, Executor1>::get(h.handler_, ex); + return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c); } }; #endif // !defined(GENERATING_DOCUMENTATION) -template <typename AsyncRandomAccessReadDevice, typename Allocator, - typename CompletionCondition, typename ReadHandler> -inline ASIO_INITFN_RESULT_TYPE(ReadHandler, +template <typename AsyncRandomAccessReadDevice, + typename Allocator, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) ReadHandler> +inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (asio::error_code, std::size_t)) async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset, asio::basic_streambuf<Allocator>& b, CompletionCondition completion_condition, 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. - ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - - async_completion<ReadHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, - CompletionCondition, ASIO_HANDLER_TYPE(ReadHandler, - void (asio::error_code, std::size_t))>( - d, offset, b, completion_condition, init.completion_handler)( - asio::error_code(), 0, 1); - - return init.result.get(); + return async_initiate<ReadHandler, + void (asio::error_code, std::size_t)>( + detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d), + handler, offset, &b, + ASIO_MOVE_CAST(CompletionCondition)(completion_condition)); } template <typename AsyncRandomAccessReadDevice, typename Allocator, - typename ReadHandler> -inline ASIO_INITFN_RESULT_TYPE(ReadHandler, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) ReadHandler> +inline ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (asio::error_code, std::size_t)) async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset, asio::basic_streambuf<Allocator>& b, 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. - ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; - - async_completion<ReadHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator, - detail::transfer_all_t, ASIO_HANDLER_TYPE(ReadHandler, - void (asio::error_code, std::size_t))>( - d, offset, b, transfer_all(), init.completion_handler)( - asio::error_code(), 0, 1); - - return init.result.get(); + return async_initiate<ReadHandler, + void (asio::error_code, std::size_t)>( + detail::initiate_async_read_at_streambuf<AsyncRandomAccessReadDevice>(d), + handler, offset, &b, transfer_all()); } #endif // !defined(ASIO_NO_IOSTREAM) |