diff options
Diffstat (limited to '3rdparty/asio/include/asio/impl/buffered_read_stream.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/impl/buffered_read_stream.hpp | 290 |
1 files changed, 181 insertions, 109 deletions
diff --git a/3rdparty/asio/include/asio/impl/buffered_read_stream.hpp b/3rdparty/asio/include/asio/impl/buffered_read_stream.hpp index c1a2e145490..a25beeedce0 100644 --- a/3rdparty/asio/include/asio/impl/buffered_read_stream.hpp +++ b/3rdparty/asio/include/asio/impl/buffered_read_stream.hpp @@ -2,7 +2,7 @@ // impl/buffered_read_stream.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) @@ -15,12 +15,13 @@ # 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/detail/handler_alloc_helpers.hpp" #include "asio/detail/handler_cont_helpers.hpp" #include "asio/detail/handler_invoke_helpers.hpp" #include "asio/detail/handler_type_requirements.hpp" +#include "asio/detail/non_const_lvalue.hpp" +#include "asio/detail/type_traits.hpp" #include "asio/detail/push_options.hpp" @@ -89,7 +90,7 @@ namespace detail const std::size_t bytes_transferred) { storage_.resize(previous_size_ + bytes_transferred); - handler_(ec, bytes_transferred); + ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(ec, bytes_transferred); } //private: @@ -99,19 +100,29 @@ namespace detail }; template <typename ReadHandler> - inline void* asio_handler_allocate(std::size_t size, + inline asio_handler_allocate_is_deprecated + asio_handler_allocate(std::size_t size, buffered_fill_handler<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 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, buffered_fill_handler<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 ReadHandler> @@ -123,77 +134,103 @@ namespace detail } template <typename Function, typename ReadHandler> - inline void asio_handler_invoke(Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(Function& function, buffered_fill_handler<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 ReadHandler> - inline void asio_handler_invoke(const Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(const Function& function, buffered_fill_handler<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 Stream> + class initiate_async_buffered_fill + { + public: + typedef typename remove_reference< + Stream>::type::lowest_layer_type::executor_type executor_type; -template <typename ReadHandler, typename Allocator> -struct associated_allocator< - detail::buffered_fill_handler<ReadHandler>, Allocator> -{ - typedef typename associated_allocator<ReadHandler, Allocator>::type type; + explicit initiate_async_buffered_fill( + typename remove_reference<Stream>::type& next_layer) + : next_layer_(next_layer) + { + } - static type get(const detail::buffered_fill_handler<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 next_layer_.lowest_layer().get_executor(); + } -template <typename ReadHandler, typename Executor> -struct associated_executor< - detail::buffered_fill_handler<ReadHandler>, Executor> -{ - typedef typename associated_executor<ReadHandler, Executor>::type type; + template <typename ReadHandler> + void operator()(ASIO_MOVE_ARG(ReadHandler) handler, + buffered_stream_storage* storage) 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); + std::size_t previous_size = storage->size(); + storage->resize(storage->capacity()); + next_layer_.async_read_some( + buffer( + storage->data() + previous_size, + storage->size() - previous_size), + buffered_fill_handler<typename decay<ReadHandler>::type>( + *storage, previous_size, handler2.value)); + } - static type get(const detail::buffered_fill_handler<ReadHandler>& h, - const Executor& ex = Executor()) ASIO_NOEXCEPT + private: + typename remove_reference<Stream>::type& next_layer_; + }; +} // namespace detail + +#if !defined(GENERATING_DOCUMENTATION) + +template <template <typename, typename> class Associator, + typename ReadHandler, typename DefaultCandidate> +struct associator<Associator, + detail::buffered_fill_handler<ReadHandler>, + DefaultCandidate> + : Associator<ReadHandler, DefaultCandidate> +{ + static typename Associator<ReadHandler, DefaultCandidate>::type get( + const detail::buffered_fill_handler<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 Stream> -template <typename ReadHandler> -ASIO_INITFN_RESULT_TYPE(ReadHandler, +template < + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) ReadHandler> +ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (asio::error_code, std::size_t)) buffered_read_stream<Stream>::async_fill( 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); - - std::size_t previous_size = storage_.size(); - storage_.resize(storage_.capacity()); - next_layer_.async_read_some( - buffer( - storage_.data() + previous_size, - storage_.size() - previous_size), - detail::buffered_fill_handler<ASIO_HANDLER_TYPE( - ReadHandler, void (asio::error_code, std::size_t))>( - storage_, previous_size, init.completion_handler)); - - return init.result.get(); + return async_initiate<ReadHandler, + void (asio::error_code, std::size_t)>( + detail::initiate_async_buffered_fill<Stream>(next_layer_), + handler, &storage_); } template <typename Stream> @@ -201,7 +238,8 @@ template <typename MutableBufferSequence> std::size_t buffered_read_stream<Stream>::read_some( const MutableBufferSequence& buffers) { - if (asio::buffer_size(buffers) == 0) + using asio::buffer_size; + if (buffer_size(buffers) == 0) return 0; if (storage_.empty()) @@ -217,7 +255,8 @@ std::size_t buffered_read_stream<Stream>::read_some( { ec = asio::error_code(); - if (asio::buffer_size(buffers) == 0) + using asio::buffer_size; + if (buffer_size(buffers) == 0) return 0; if (storage_.empty() && !this->fill(ec)) @@ -261,14 +300,14 @@ namespace detail if (ec || storage_.empty()) { const std::size_t length = 0; - handler_(ec, length); + ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(ec, length); } else { const std::size_t bytes_copied = asio::buffer_copy( buffers_, storage_.data(), storage_.size()); storage_.consume(bytes_copied); - handler_(ec, bytes_copied); + ASIO_MOVE_OR_LVALUE(ReadHandler)(handler_)(ec, bytes_copied); } } @@ -279,21 +318,31 @@ namespace detail }; template <typename MutableBufferSequence, typename ReadHandler> - inline void* asio_handler_allocate(std::size_t size, + inline asio_handler_allocate_is_deprecated + asio_handler_allocate(std::size_t size, buffered_read_some_handler< MutableBufferSequence, 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 MutableBufferSequence, 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, buffered_read_some_handler< MutableBufferSequence, 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 MutableBufferSequence, typename ReadHandler> @@ -307,95 +356,118 @@ namespace detail template <typename Function, typename MutableBufferSequence, typename ReadHandler> - inline void asio_handler_invoke(Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(Function& function, buffered_read_some_handler< MutableBufferSequence, 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 MutableBufferSequence, typename ReadHandler> - inline void asio_handler_invoke(const Function& function, + inline asio_handler_invoke_is_deprecated + asio_handler_invoke(const Function& function, buffered_read_some_handler< MutableBufferSequence, 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 Stream> + class initiate_async_buffered_read_some + { + public: + typedef typename remove_reference< + Stream>::type::lowest_layer_type::executor_type executor_type; -template <typename MutableBufferSequence, - typename ReadHandler, typename Allocator> -struct associated_allocator< - detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>, - Allocator> -{ - typedef typename associated_allocator<ReadHandler, Allocator>::type type; + explicit initiate_async_buffered_read_some( + typename remove_reference<Stream>::type& next_layer) + : next_layer_(next_layer) + { + } - static type get( - const detail::buffered_read_some_handler< - MutableBufferSequence, 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 next_layer_.lowest_layer().get_executor(); + } -template <typename MutableBufferSequence, - typename ReadHandler, typename Executor> -struct associated_executor< + template <typename ReadHandler, typename MutableBufferSequence> + void operator()(ASIO_MOVE_ARG(ReadHandler) handler, + buffered_stream_storage* storage, + const MutableBufferSequence& buffers) 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; + + using asio::buffer_size; + non_const_lvalue<ReadHandler> handler2(handler); + if (buffer_size(buffers) == 0 || !storage->empty()) + { + next_layer_.async_read_some(ASIO_MUTABLE_BUFFER(0, 0), + buffered_read_some_handler<MutableBufferSequence, + typename decay<ReadHandler>::type>( + *storage, buffers, handler2.value)); + } + else + { + initiate_async_buffered_fill<Stream>(this->next_layer_)( + buffered_read_some_handler<MutableBufferSequence, + typename decay<ReadHandler>::type>( + *storage, buffers, handler2.value), + storage); + } + } + + private: + typename remove_reference<Stream>::type& next_layer_; + }; +} // namespace detail + +#if !defined(GENERATING_DOCUMENTATION) + +template <template <typename, typename> class Associator, + typename MutableBufferSequence, typename ReadHandler, + typename DefaultCandidate> +struct associator<Associator, detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>, - Executor> + DefaultCandidate> + : Associator<ReadHandler, DefaultCandidate> { - typedef typename associated_executor<ReadHandler, Executor>::type type; - - static type get( + static typename Associator<ReadHandler, DefaultCandidate>::type get( const detail::buffered_read_some_handler< MutableBufferSequence, ReadHandler>& h, - const Executor& ex = Executor()) ASIO_NOEXCEPT + 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 Stream> -template <typename MutableBufferSequence, typename ReadHandler> -ASIO_INITFN_RESULT_TYPE(ReadHandler, +template <typename MutableBufferSequence, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) ReadHandler> +ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (asio::error_code, std::size_t)) buffered_read_stream<Stream>::async_read_some( 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); - - if (asio::buffer_size(buffers) == 0 || !storage_.empty()) - { - next_layer_.async_read_some(ASIO_MUTABLE_BUFFER(0, 0), - detail::buffered_read_some_handler< - MutableBufferSequence, ASIO_HANDLER_TYPE( - ReadHandler, void (asio::error_code, std::size_t))>( - storage_, buffers, init.completion_handler)); - } - else - { - this->async_fill(detail::buffered_read_some_handler< - MutableBufferSequence, ASIO_HANDLER_TYPE( - ReadHandler, void (asio::error_code, std::size_t))>( - storage_, buffers, init.completion_handler)); - } - - return init.result.get(); + return async_initiate<ReadHandler, + void (asio::error_code, std::size_t)>( + detail::initiate_async_buffered_read_some<Stream>(next_layer_), + handler, &storage_, buffers); } template <typename Stream> |