diff options
Diffstat (limited to '3rdparty/asio/include/asio/impl/write.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/impl/write.hpp | 907 |
1 files changed, 586 insertions, 321 deletions
diff --git a/3rdparty/asio/include/asio/impl/write.hpp b/3rdparty/asio/include/asio/impl/write.hpp index 8250aa30361..af2bb5544bb 100644 --- a/3rdparty/asio/include/asio/impl/write.hpp +++ b/3rdparty/asio/include/asio/impl/write.hpp @@ -2,7 +2,7 @@ // impl/write.hpp // ~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 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) @@ -15,19 +15,18 @@ # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) -#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" #include "asio/detail/dependent_type.hpp" -#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/detail/push_options.hpp" @@ -38,7 +37,7 @@ namespace detail { template <typename SyncWriteStream, typename ConstBufferSequence, typename ConstBufferIterator, typename CompletionCondition> - std::size_t write_buffer_sequence(SyncWriteStream& s, + std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, const ConstBufferIterator&, CompletionCondition completion_condition, asio::error_code& ec) { @@ -53,7 +52,7 @@ namespace detail else break; } - return tmp.total_consumed();; + return tmp.total_consumed(); } } // namespace detail @@ -61,19 +60,20 @@ template <typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, CompletionCondition completion_condition, asio::error_code& ec, - typename enable_if< + constraint_t< is_const_buffer_sequence<ConstBufferSequence>::value - >::type*) + >) { - return detail::write_buffer_sequence(s, buffers, - asio::buffer_sequence_begin(buffers), completion_condition, ec); + return detail::write(s, buffers, + asio::buffer_sequence_begin(buffers), + static_cast<CompletionCondition&&>(completion_condition), ec); } template <typename SyncWriteStream, typename ConstBufferSequence> inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, - typename enable_if< + constraint_t< is_const_buffer_sequence<ConstBufferSequence>::value - >::type*) + >) { asio::error_code ec; std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec); @@ -84,9 +84,9 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, template <typename SyncWriteStream, typename ConstBufferSequence> inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, asio::error_code& ec, - typename enable_if< + constraint_t< is_const_buffer_sequence<ConstBufferSequence>::value - >::type*) + >) { return write(s, buffers, transfer_all(), ec); } @@ -95,73 +95,89 @@ template <typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, CompletionCondition completion_condition, - typename enable_if< + constraint_t< is_const_buffer_sequence<ConstBufferSequence>::value - >::type*) + >) { asio::error_code ec; - std::size_t bytes_transferred = write(s, buffers, completion_condition, ec); + std::size_t bytes_transferred = write(s, buffers, + static_cast<CompletionCondition&&>(completion_condition), ec); asio::detail::throw_error(ec, "write"); return bytes_transferred; } -template <typename SyncWriteStream, typename DynamicBuffer, +#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1) + +template <typename SyncWriteStream, typename DynamicBuffer_v1, typename CompletionCondition> std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + DynamicBuffer_v1&& buffers, CompletionCondition completion_condition, asio::error_code& ec, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type*) + constraint_t< + is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value + >, + constraint_t< + !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value + >) { - typename decay<DynamicBuffer>::type b( - ASIO_MOVE_CAST(DynamicBuffer)(buffers)); + decay_t<DynamicBuffer_v1> b( + static_cast<DynamicBuffer_v1&&>(buffers)); - std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec); + std::size_t bytes_transferred = write(s, b.data(), + static_cast<CompletionCondition&&>(completion_condition), ec); b.consume(bytes_transferred); return bytes_transferred; } -template <typename SyncWriteStream, typename DynamicBuffer> +template <typename SyncWriteStream, typename DynamicBuffer_v1> inline std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type*) + DynamicBuffer_v1&& buffers, + constraint_t< + is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value + >, + constraint_t< + !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value + >) { asio::error_code ec; std::size_t bytes_transferred = write(s, - ASIO_MOVE_CAST(DynamicBuffer)(buffers), + static_cast<DynamicBuffer_v1&&>(buffers), transfer_all(), ec); asio::detail::throw_error(ec, "write"); return bytes_transferred; } -template <typename SyncWriteStream, typename DynamicBuffer> +template <typename SyncWriteStream, typename DynamicBuffer_v1> inline std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + DynamicBuffer_v1&& buffers, asio::error_code& ec, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type*) + constraint_t< + is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value + >, + constraint_t< + !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value + >) { - return write(s, ASIO_MOVE_CAST(DynamicBuffer)(buffers), + return write(s, static_cast<DynamicBuffer_v1&&>(buffers), transfer_all(), ec); } -template <typename SyncWriteStream, typename DynamicBuffer, +template <typename SyncWriteStream, typename DynamicBuffer_v1, typename CompletionCondition> inline std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + DynamicBuffer_v1&& buffers, CompletionCondition completion_condition, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type*) + constraint_t< + is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value + >, + constraint_t< + !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value + >) { asio::error_code ec; std::size_t bytes_transferred = write(s, - ASIO_MOVE_CAST(DynamicBuffer)(buffers), - completion_condition, ec); + static_cast<DynamicBuffer_v1&&>(buffers), + static_cast<CompletionCondition&&>(completion_condition), ec); asio::detail::throw_error(ec, "write"); return bytes_transferred; } @@ -175,7 +191,8 @@ inline std::size_t write(SyncWriteStream& s, asio::basic_streambuf<Allocator>& b, CompletionCondition completion_condition, asio::error_code& ec) { - return write(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec); + return write(s, basic_streambuf_ref<Allocator>(b), + static_cast<CompletionCondition&&>(completion_condition), ec); } template <typename SyncWriteStream, typename Allocator> @@ -199,11 +216,68 @@ inline std::size_t write(SyncWriteStream& s, asio::basic_streambuf<Allocator>& b, CompletionCondition completion_condition) { - return write(s, basic_streambuf_ref<Allocator>(b), completion_condition); + return write(s, basic_streambuf_ref<Allocator>(b), + static_cast<CompletionCondition&&>(completion_condition)); } #endif // !defined(ASIO_NO_IOSTREAM) #endif // !defined(ASIO_NO_EXTENSIONS) +#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1) + +template <typename SyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition> +std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + CompletionCondition completion_condition, asio::error_code& ec, + constraint_t< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >) +{ + std::size_t bytes_transferred = write(s, buffers.data(0, buffers.size()), + static_cast<CompletionCondition&&>(completion_condition), ec); + buffers.consume(bytes_transferred); + return bytes_transferred; +} + +template <typename SyncWriteStream, typename DynamicBuffer_v2> +inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + constraint_t< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >) +{ + asio::error_code ec; + std::size_t bytes_transferred = write(s, + static_cast<DynamicBuffer_v2&&>(buffers), + transfer_all(), ec); + asio::detail::throw_error(ec, "write"); + return bytes_transferred; +} + +template <typename SyncWriteStream, typename DynamicBuffer_v2> +inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + asio::error_code& ec, + constraint_t< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >) +{ + return write(s, static_cast<DynamicBuffer_v2&&>(buffers), + transfer_all(), ec); +} + +template <typename SyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition> +inline std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + CompletionCondition completion_condition, + constraint_t< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >) +{ + asio::error_code ec; + std::size_t bytes_transferred = write(s, + static_cast<DynamicBuffer_v2&&>(buffers), + static_cast<CompletionCondition&&>(completion_condition), ec); + asio::detail::throw_error(ec, "write"); + return bytes_transferred; +} namespace detail { @@ -211,23 +285,25 @@ namespace detail typename ConstBufferIterator, typename CompletionCondition, typename WriteHandler> class write_op - : detail::base_from_completion_cond<CompletionCondition> + : public base_from_cancellation_state<WriteHandler>, + base_from_completion_cond<CompletionCondition> { public: write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers, - CompletionCondition completion_condition, WriteHandler& handler) - : detail::base_from_completion_cond< - CompletionCondition>(completion_condition), + CompletionCondition& completion_condition, WriteHandler& handler) + : base_from_cancellation_state<WriteHandler>( + handler, enable_partial_cancellation()), + base_from_completion_cond<CompletionCondition>(completion_condition), stream_(stream), buffers_(buffers), start_(0), - handler_(ASIO_MOVE_CAST(WriteHandler)(handler)) + handler_(static_cast<WriteHandler&&>(handler)) { } -#if defined(ASIO_HAS_MOVE) write_op(const write_op& other) - : detail::base_from_completion_cond<CompletionCondition>(other), + : base_from_cancellation_state<WriteHandler>(other), + base_from_completion_cond<CompletionCondition>(other), stream_(other.stream_), buffers_(other.buffers_), start_(other.start_), @@ -236,16 +312,18 @@ namespace detail } write_op(write_op&& other) - : detail::base_from_completion_cond<CompletionCondition>(other), + : base_from_cancellation_state<WriteHandler>( + static_cast<base_from_cancellation_state<WriteHandler>&&>(other)), + base_from_completion_cond<CompletionCondition>( + static_cast<base_from_completion_cond<CompletionCondition>&&>(other)), stream_(other.stream_), - buffers_(other.buffers_), + buffers_(static_cast<buffers_type&&>(other.buffers_)), start_(other.start_), - handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_)) + handler_(static_cast<WriteHandler&&>(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; @@ -253,25 +331,39 @@ namespace detail { case 1: max_size = this->check_for_completion(ec, buffers_.total_consumed()); - do + for (;;) { - stream_.async_write_some(buffers_.prepare(max_size), - ASIO_MOVE_CAST(write_op)(*this)); + { + ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_write")); + stream_.async_write_some(buffers_.prepare(max_size), + static_cast<write_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 = error::operation_aborted; + break; + } + } - handler_(ec, buffers_.total_consumed()); + static_cast<WriteHandler&&>(handler_)( + static_cast<const asio::error_code&>(ec), + static_cast<const std::size_t&>(buffers_.total_consumed())); } } //private: + typedef asio::detail::consuming_buffers<const_buffer, + ConstBufferSequence, ConstBufferIterator> buffers_type; + AsyncWriteStream& stream_; - asio::detail::consuming_buffers<const_buffer, - ConstBufferSequence, ConstBufferIterator> buffers_; + buffers_type buffers_; int start_; WriteHandler handler_; }; @@ -279,28 +371,6 @@ namespace detail template <typename AsyncWriteStream, typename ConstBufferSequence, typename ConstBufferIterator, typename CompletionCondition, typename WriteHandler> - inline void* asio_handler_allocate(std::size_t size, - write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, - CompletionCondition, WriteHandler>* this_handler) - { - return asio_handler_alloc_helpers::allocate( - size, this_handler->handler_); - } - - template <typename AsyncWriteStream, typename ConstBufferSequence, - typename ConstBufferIterator, typename CompletionCondition, - typename WriteHandler> - inline void asio_handler_deallocate(void* pointer, std::size_t size, - write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, - CompletionCondition, WriteHandler>* this_handler) - { - asio_handler_alloc_helpers::deallocate( - pointer, size, this_handler->handler_); - } - - template <typename AsyncWriteStream, typename ConstBufferSequence, - typename ConstBufferIterator, typename CompletionCondition, - typename WriteHandler> inline bool asio_handler_is_continuation( write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler) @@ -310,34 +380,12 @@ namespace detail this_handler->handler_); } - template <typename Function, typename AsyncWriteStream, - typename ConstBufferSequence, typename ConstBufferIterator, - typename CompletionCondition, typename WriteHandler> - inline void asio_handler_invoke(Function& function, - write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, - CompletionCondition, WriteHandler>* this_handler) - { - asio_handler_invoke_helpers::invoke( - function, this_handler->handler_); - } - - template <typename Function, typename AsyncWriteStream, - typename ConstBufferSequence, typename ConstBufferIterator, - typename CompletionCondition, typename WriteHandler> - inline void asio_handler_invoke(const Function& function, - write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, - CompletionCondition, WriteHandler>* this_handler) - { - asio_handler_invoke_helpers::invoke( - function, this_handler->handler_); - } - template <typename AsyncWriteStream, typename ConstBufferSequence, typename ConstBufferIterator, typename CompletionCondition, typename WriteHandler> - inline void start_write_buffer_sequence_op(AsyncWriteStream& stream, + inline void start_write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers, const ConstBufferIterator&, - CompletionCondition completion_condition, WriteHandler& handler) + CompletionCondition& completion_condition, WriteHandler& handler) { detail::write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, CompletionCondition, WriteHandler>( @@ -345,120 +393,140 @@ namespace detail asio::error_code(), 0, 1); } + template <typename AsyncWriteStream> + class initiate_async_write + { + public: + typedef typename AsyncWriteStream::executor_type executor_type; + + explicit initiate_async_write(AsyncWriteStream& stream) + : stream_(stream) + { + } + + executor_type get_executor() const noexcept + { + return stream_.get_executor(); + } + + template <typename WriteHandler, typename ConstBufferSequence, + typename CompletionCondition> + void operator()(WriteHandler&& handler, + const ConstBufferSequence& buffers, + 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 WriteHandler. + ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; + + non_const_lvalue<WriteHandler> handler2(handler); + non_const_lvalue<CompletionCondition> completion_cond2(completion_cond); + start_write_op(stream_, buffers, + asio::buffer_sequence_begin(buffers), + completion_cond2.value, handler2.value); + } + + private: + AsyncWriteStream& stream_; + }; } // namespace detail #if !defined(GENERATING_DOCUMENTATION) -template <typename AsyncWriteStream, typename ConstBufferSequence, +template <template <typename, typename> class Associator, + typename AsyncWriteStream, typename ConstBufferSequence, typename ConstBufferIterator, typename CompletionCondition, - typename WriteHandler, typename Allocator> -struct associated_allocator< + typename WriteHandler, typename DefaultCandidate> +struct associator<Associator, detail::write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, CompletionCondition, WriteHandler>, - Allocator> + DefaultCandidate> + : Associator<WriteHandler, DefaultCandidate> { - typedef typename associated_allocator<WriteHandler, Allocator>::type type; - - static type get( + static typename Associator<WriteHandler, DefaultCandidate>::type get( const detail::write_op<AsyncWriteStream, ConstBufferSequence, - ConstBufferIterator, CompletionCondition, WriteHandler>& h, - const Allocator& a = Allocator()) ASIO_NOEXCEPT + ConstBufferIterator, CompletionCondition, WriteHandler>& h) noexcept { - return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a); + return Associator<WriteHandler, DefaultCandidate>::get(h.handler_); } -}; - -template <typename AsyncWriteStream, typename ConstBufferSequence, - typename ConstBufferIterator, typename CompletionCondition, - typename WriteHandler, typename Executor> -struct associated_executor< - detail::write_op<AsyncWriteStream, ConstBufferSequence, - ConstBufferIterator, CompletionCondition, WriteHandler>, - Executor> -{ - typedef typename associated_executor<WriteHandler, Executor>::type type; - static type get( + static auto get( const detail::write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator, CompletionCondition, WriteHandler>& h, - const Executor& ex = Executor()) ASIO_NOEXCEPT + const DefaultCandidate& c) noexcept + -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c)) { - return associated_executor<WriteHandler, Executor>::get(h.handler_, ex); + return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c); } }; #endif // !defined(GENERATING_DOCUMENTATION) -template <typename AsyncWriteStream, typename ConstBufferSequence, - typename CompletionCondition, typename WriteHandler> -inline ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) -async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, - CompletionCondition completion_condition, - ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< +template <typename AsyncWriteStream, + typename ConstBufferSequence, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, + CompletionCondition completion_condition, WriteToken&& token, + constraint_t< is_const_buffer_sequence<ConstBufferSequence>::value - >::type*) + >) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write<AsyncWriteStream>>(), + token, buffers, + static_cast<CompletionCondition&&>(completion_condition))) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a WriteHandler. - ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; - - async_completion<WriteHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::start_write_buffer_sequence_op(s, buffers, - asio::buffer_sequence_begin(buffers), completion_condition, - init.completion_handler); - - return init.result.get(); + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write<AsyncWriteStream>(s), + token, buffers, + static_cast<CompletionCondition&&>(completion_condition)); } template <typename AsyncWriteStream, typename ConstBufferSequence, - typename WriteHandler> -inline ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) -async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, - ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, + const ConstBufferSequence& buffers, WriteToken&& token, + constraint_t< is_const_buffer_sequence<ConstBufferSequence>::value - >::type*) + >) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write<AsyncWriteStream>>(), + token, buffers, transfer_all())) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a WriteHandler. - ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; - - async_completion<WriteHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::start_write_buffer_sequence_op(s, buffers, - asio::buffer_sequence_begin(buffers), transfer_all(), - init.completion_handler); - - return init.result.get(); + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write<AsyncWriteStream>(s), + token, buffers, transfer_all()); } +#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1) + namespace detail { - template <typename AsyncWriteStream, typename DynamicBuffer, + template <typename AsyncWriteStream, typename DynamicBuffer_v1, typename CompletionCondition, typename WriteHandler> - class write_dynbuf_op + class write_dynbuf_v1_op { public: template <typename BufferSequence> - write_dynbuf_op(AsyncWriteStream& stream, - ASIO_MOVE_ARG(BufferSequence) buffers, - CompletionCondition completion_condition, WriteHandler& handler) + write_dynbuf_v1_op(AsyncWriteStream& stream, + BufferSequence&& buffers, + CompletionCondition& completion_condition, WriteHandler& handler) : stream_(stream), - buffers_(ASIO_MOVE_CAST(BufferSequence)(buffers)), + buffers_(static_cast<BufferSequence&&>(buffers)), completion_condition_( - ASIO_MOVE_CAST(CompletionCondition)(completion_condition)), - handler_(ASIO_MOVE_CAST(WriteHandler)(handler)) + static_cast<CompletionCondition&&>(completion_condition)), + handler_(static_cast<WriteHandler&&>(handler)) { } -#if defined(ASIO_HAS_MOVE) - write_dynbuf_op(const write_dynbuf_op& other) + write_dynbuf_v1_op(const write_dynbuf_v1_op& other) : stream_(other.stream_), buffers_(other.buffers_), completion_condition_(other.completion_condition_), @@ -466,16 +534,15 @@ namespace detail { } - write_dynbuf_op(write_dynbuf_op&& other) + write_dynbuf_v1_op(write_dynbuf_v1_op&& other) : stream_(other.stream_), - buffers_(ASIO_MOVE_CAST(DynamicBuffer)(other.buffers_)), + buffers_(static_cast<DynamicBuffer_v1&&>(other.buffers_)), completion_condition_( - ASIO_MOVE_CAST(CompletionCondition)( + static_cast<CompletionCondition&&>( other.completion_condition_)), - handler_(ASIO_MOVE_CAST(WriteHandler)(other.handler_)) + handler_(static_cast<WriteHandler&&>(other.handler_)) { } -#endif // defined(ASIO_HAS_MOVE) void operator()(const asio::error_code& ec, std::size_t bytes_transferred, int start = 0) @@ -483,189 +550,387 @@ namespace detail switch (start) { case 1: - async_write(stream_, buffers_.data(), completion_condition_, - ASIO_MOVE_CAST(write_dynbuf_op)(*this)); + async_write(stream_, buffers_.data(), + static_cast<CompletionCondition&&>(completion_condition_), + static_cast<write_dynbuf_v1_op&&>(*this)); return; default: buffers_.consume(bytes_transferred); - handler_(ec, static_cast<const std::size_t&>(bytes_transferred)); + static_cast<WriteHandler&&>(handler_)(ec, + static_cast<const std::size_t&>(bytes_transferred)); } } //private: AsyncWriteStream& stream_; - DynamicBuffer buffers_; + DynamicBuffer_v1 buffers_; CompletionCondition completion_condition_; WriteHandler handler_; }; - template <typename AsyncWriteStream, typename DynamicBuffer, - typename CompletionCondition, typename WriteHandler> - inline void* asio_handler_allocate(std::size_t size, - write_dynbuf_op<AsyncWriteStream, DynamicBuffer, - CompletionCondition, WriteHandler>* this_handler) - { - return asio_handler_alloc_helpers::allocate( - size, this_handler->handler_); - } - - template <typename AsyncWriteStream, typename DynamicBuffer, - typename CompletionCondition, typename WriteHandler> - inline void asio_handler_deallocate(void* pointer, std::size_t size, - write_dynbuf_op<AsyncWriteStream, DynamicBuffer, - CompletionCondition, WriteHandler>* this_handler) - { - asio_handler_alloc_helpers::deallocate( - pointer, size, this_handler->handler_); - } - - template <typename AsyncWriteStream, typename DynamicBuffer, + template <typename AsyncWriteStream, typename DynamicBuffer_v1, typename CompletionCondition, typename WriteHandler> inline bool asio_handler_is_continuation( - write_dynbuf_op<AsyncWriteStream, DynamicBuffer, + write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1, CompletionCondition, WriteHandler>* this_handler) { return asio_handler_cont_helpers::is_continuation( this_handler->handler_); } - template <typename Function, typename AsyncWriteStream, - typename DynamicBuffer, typename CompletionCondition, - typename WriteHandler> - inline void asio_handler_invoke(Function& function, - write_dynbuf_op<AsyncWriteStream, DynamicBuffer, - CompletionCondition, WriteHandler>* this_handler) + template <typename AsyncWriteStream> + class initiate_async_write_dynbuf_v1 { - asio_handler_invoke_helpers::invoke( - function, this_handler->handler_); - } + public: + typedef typename AsyncWriteStream::executor_type executor_type; - template <typename Function, typename AsyncWriteStream, - typename DynamicBuffer, typename CompletionCondition, - typename WriteHandler> - inline void asio_handler_invoke(const Function& function, - write_dynbuf_op<AsyncWriteStream, DynamicBuffer, - CompletionCondition, WriteHandler>* this_handler) - { - asio_handler_invoke_helpers::invoke( - function, this_handler->handler_); - } + explicit initiate_async_write_dynbuf_v1(AsyncWriteStream& stream) + : stream_(stream) + { + } + + executor_type get_executor() const noexcept + { + return stream_.get_executor(); + } + + template <typename WriteHandler, typename DynamicBuffer_v1, + typename CompletionCondition> + void operator()(WriteHandler&& handler, + DynamicBuffer_v1&& buffers, + 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 WriteHandler. + ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; + + non_const_lvalue<WriteHandler> handler2(handler); + non_const_lvalue<CompletionCondition> completion_cond2(completion_cond); + write_dynbuf_v1_op<AsyncWriteStream, + decay_t<DynamicBuffer_v1>, + CompletionCondition, decay_t<WriteHandler>>( + stream_, static_cast<DynamicBuffer_v1&&>(buffers), + completion_cond2.value, handler2.value)( + asio::error_code(), 0, 1); + } + + private: + AsyncWriteStream& stream_; + }; } // namespace detail #if !defined(GENERATING_DOCUMENTATION) -template <typename AsyncWriteStream, typename DynamicBuffer, - typename CompletionCondition, typename WriteHandler, typename Allocator> -struct associated_allocator< - detail::write_dynbuf_op<AsyncWriteStream, - DynamicBuffer, CompletionCondition, WriteHandler>, - Allocator> +template <template <typename, typename> class Associator, + typename AsyncWriteStream, typename DynamicBuffer_v1, + typename CompletionCondition, typename WriteHandler, + typename DefaultCandidate> +struct associator<Associator, + detail::write_dynbuf_v1_op<AsyncWriteStream, + DynamicBuffer_v1, CompletionCondition, WriteHandler>, + DefaultCandidate> + : Associator<WriteHandler, DefaultCandidate> { - typedef typename associated_allocator<WriteHandler, Allocator>::type type; - - static type get( - const detail::write_dynbuf_op<AsyncWriteStream, - DynamicBuffer, CompletionCondition, WriteHandler>& h, - const Allocator& a = Allocator()) ASIO_NOEXCEPT + static typename Associator<WriteHandler, DefaultCandidate>::type get( + const detail::write_dynbuf_v1_op<AsyncWriteStream, DynamicBuffer_v1, + CompletionCondition, WriteHandler>& h) noexcept { - return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a); + return Associator<WriteHandler, DefaultCandidate>::get(h.handler_); } -}; - -template <typename AsyncWriteStream, typename DynamicBuffer, - typename CompletionCondition, typename WriteHandler, typename Executor> -struct associated_executor< - detail::write_dynbuf_op<AsyncWriteStream, - DynamicBuffer, CompletionCondition, WriteHandler>, - Executor> -{ - typedef typename associated_executor<WriteHandler, Executor>::type type; - static type get( - const detail::write_dynbuf_op<AsyncWriteStream, - DynamicBuffer, CompletionCondition, WriteHandler>& h, - const Executor& ex = Executor()) ASIO_NOEXCEPT + static auto get( + const detail::write_dynbuf_v1_op<AsyncWriteStream, + DynamicBuffer_v1, CompletionCondition, WriteHandler>& h, + const DefaultCandidate& c) noexcept + -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c)) { - return associated_executor<WriteHandler, Executor>::get(h.handler_, ex); + return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c); } }; #endif // !defined(GENERATING_DOCUMENTATION) -template <typename AsyncWriteStream, - typename DynamicBuffer, typename WriteHandler> -inline ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) -async_write(AsyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, - ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type*) +template <typename AsyncWriteStream, typename DynamicBuffer_v1, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, + DynamicBuffer_v1&& buffers, WriteToken&& token, + constraint_t< + is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value + >, + constraint_t< + !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value + >) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(), + token, static_cast<DynamicBuffer_v1&&>(buffers), + transfer_all())) { - return async_write(s, - ASIO_MOVE_CAST(DynamicBuffer)(buffers), - transfer_all(), ASIO_MOVE_CAST(WriteHandler)(handler)); + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s), + token, static_cast<DynamicBuffer_v1&&>(buffers), + transfer_all()); } -template <typename AsyncWriteStream, typename DynamicBuffer, - typename CompletionCondition, typename WriteHandler> -inline ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) -async_write(AsyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, - CompletionCondition completion_condition, - ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type*) +template <typename AsyncWriteStream, + typename DynamicBuffer_v1, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v1&& buffers, + CompletionCondition completion_condition, WriteToken&& token, + constraint_t< + is_dynamic_buffer_v1<decay_t<DynamicBuffer_v1>>::value + >, + constraint_t< + !is_dynamic_buffer_v2<decay_t<DynamicBuffer_v1>>::value + >) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(), + token, static_cast<DynamicBuffer_v1&&>(buffers), + static_cast<CompletionCondition&&>(completion_condition))) { - // If you get an error on the following line it means that your handler does - // not meet the documented type requirements for a WriteHandler. - ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; - - async_completion<WriteHandler, - void (asio::error_code, std::size_t)> init(handler); - - detail::write_dynbuf_op<AsyncWriteStream, - typename decay<DynamicBuffer>::type, - CompletionCondition, ASIO_HANDLER_TYPE( - WriteHandler, void (asio::error_code, std::size_t))>( - s, ASIO_MOVE_CAST(DynamicBuffer)(buffers), - completion_condition, init.completion_handler)( - asio::error_code(), 0, 1); - - return init.result.get(); + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s), + token, static_cast<DynamicBuffer_v1&&>(buffers), + static_cast<CompletionCondition&&>(completion_condition)); } #if !defined(ASIO_NO_EXTENSIONS) #if !defined(ASIO_NO_IOSTREAM) -template <typename AsyncWriteStream, typename Allocator, typename WriteHandler> -inline ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) -async_write(AsyncWriteStream& s, +template <typename AsyncWriteStream, typename Allocator, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, asio::basic_streambuf<Allocator>& b, - ASIO_MOVE_ARG(WriteHandler) handler) + WriteToken&& token) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(), + token, basic_streambuf_ref<Allocator>(b), transfer_all())) { - return async_write(s, basic_streambuf_ref<Allocator>(b), - ASIO_MOVE_CAST(WriteHandler)(handler)); + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s), + token, basic_streambuf_ref<Allocator>(b), transfer_all()); } -template <typename AsyncWriteStream, typename Allocator, - typename CompletionCondition, typename WriteHandler> -inline ASIO_INITFN_RESULT_TYPE(WriteHandler, - void (asio::error_code, std::size_t)) -async_write(AsyncWriteStream& s, +template <typename AsyncWriteStream, + typename Allocator, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, asio::basic_streambuf<Allocator>& b, - CompletionCondition completion_condition, - ASIO_MOVE_ARG(WriteHandler) handler) + CompletionCondition completion_condition, WriteToken&& token) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>>(), + token, basic_streambuf_ref<Allocator>(b), + static_cast<CompletionCondition&&>(completion_condition))) { - return async_write(s, basic_streambuf_ref<Allocator>(b), - completion_condition, ASIO_MOVE_CAST(WriteHandler)(handler)); + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write_dynbuf_v1<AsyncWriteStream>(s), + token, basic_streambuf_ref<Allocator>(b), + static_cast<CompletionCondition&&>(completion_condition)); } #endif // !defined(ASIO_NO_IOSTREAM) #endif // !defined(ASIO_NO_EXTENSIONS) +#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1) + +namespace detail +{ + template <typename AsyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition, typename WriteHandler> + class write_dynbuf_v2_op + { + public: + template <typename BufferSequence> + write_dynbuf_v2_op(AsyncWriteStream& stream, + BufferSequence&& buffers, + CompletionCondition& completion_condition, WriteHandler& handler) + : stream_(stream), + buffers_(static_cast<BufferSequence&&>(buffers)), + completion_condition_( + static_cast<CompletionCondition&&>(completion_condition)), + handler_(static_cast<WriteHandler&&>(handler)) + { + } + + write_dynbuf_v2_op(const write_dynbuf_v2_op& other) + : stream_(other.stream_), + buffers_(other.buffers_), + completion_condition_(other.completion_condition_), + handler_(other.handler_) + { + } + + write_dynbuf_v2_op(write_dynbuf_v2_op&& other) + : stream_(other.stream_), + buffers_(static_cast<DynamicBuffer_v2&&>(other.buffers_)), + completion_condition_( + static_cast<CompletionCondition&&>( + other.completion_condition_)), + handler_(static_cast<WriteHandler&&>(other.handler_)) + { + } + + void operator()(const asio::error_code& ec, + std::size_t bytes_transferred, int start = 0) + { + switch (start) + { + case 1: + async_write(stream_, buffers_.data(0, buffers_.size()), + static_cast<CompletionCondition&&>(completion_condition_), + static_cast<write_dynbuf_v2_op&&>(*this)); + return; default: + buffers_.consume(bytes_transferred); + static_cast<WriteHandler&&>(handler_)(ec, + static_cast<const std::size_t&>(bytes_transferred)); + } + } + + //private: + AsyncWriteStream& stream_; + DynamicBuffer_v2 buffers_; + CompletionCondition completion_condition_; + WriteHandler handler_; + }; + + template <typename AsyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition, typename WriteHandler> + inline bool asio_handler_is_continuation( + write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2, + CompletionCondition, WriteHandler>* this_handler) + { + return asio_handler_cont_helpers::is_continuation( + this_handler->handler_); + } + + template <typename AsyncWriteStream> + class initiate_async_write_dynbuf_v2 + { + public: + typedef typename AsyncWriteStream::executor_type executor_type; + + explicit initiate_async_write_dynbuf_v2(AsyncWriteStream& stream) + : stream_(stream) + { + } + + executor_type get_executor() const noexcept + { + return stream_.get_executor(); + } + + template <typename WriteHandler, typename DynamicBuffer_v2, + typename CompletionCondition> + void operator()(WriteHandler&& handler, + DynamicBuffer_v2&& buffers, + 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 WriteHandler. + ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; + + non_const_lvalue<WriteHandler> handler2(handler); + non_const_lvalue<CompletionCondition> completion_cond2(completion_cond); + write_dynbuf_v2_op<AsyncWriteStream, decay_t<DynamicBuffer_v2>, + CompletionCondition, decay_t<WriteHandler>>( + stream_, static_cast<DynamicBuffer_v2&&>(buffers), + completion_cond2.value, handler2.value)( + asio::error_code(), 0, 1); + } + + private: + AsyncWriteStream& stream_; + }; +} // namespace detail + +#if !defined(GENERATING_DOCUMENTATION) + +template <template <typename, typename> class Associator, + typename AsyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition, typename WriteHandler, + typename DefaultCandidate> +struct associator<Associator, + detail::write_dynbuf_v2_op<AsyncWriteStream, + DynamicBuffer_v2, CompletionCondition, WriteHandler>, + DefaultCandidate> + : Associator<WriteHandler, DefaultCandidate> +{ + static typename Associator<WriteHandler, DefaultCandidate>::type get( + const detail::write_dynbuf_v2_op<AsyncWriteStream, DynamicBuffer_v2, + CompletionCondition, WriteHandler>& h) noexcept + { + return Associator<WriteHandler, DefaultCandidate>::get(h.handler_); + } + + static auto get( + const detail::write_dynbuf_v2_op<AsyncWriteStream, + DynamicBuffer_v2, CompletionCondition, WriteHandler>& h, + const DefaultCandidate& c) noexcept + -> decltype(Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c)) + { + return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c); + } +}; + +#endif // !defined(GENERATING_DOCUMENTATION) + +template <typename AsyncWriteStream, typename DynamicBuffer_v2, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, + DynamicBuffer_v2 buffers, WriteToken&& token, + constraint_t< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>>(), + token, static_cast<DynamicBuffer_v2&&>(buffers), + transfer_all())) +{ + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s), + token, static_cast<DynamicBuffer_v2&&>(buffers), + transfer_all()); +} + +template <typename AsyncWriteStream, + typename DynamicBuffer_v2, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteToken> +inline auto async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers, + CompletionCondition completion_condition, WriteToken&& token, + constraint_t< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >) + -> decltype( + async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + declval<detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>>(), + token, static_cast<DynamicBuffer_v2&&>(buffers), + static_cast<CompletionCondition&&>(completion_condition))) +{ + return async_initiate<WriteToken, + void (asio::error_code, std::size_t)>( + detail::initiate_async_write_dynbuf_v2<AsyncWriteStream>(s), + token, static_cast<DynamicBuffer_v2&&>(buffers), + static_cast<CompletionCondition&&>(completion_condition)); +} } // namespace asio |