// // impl/buffered_read_stream.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // 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) // #ifndef BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP #define BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include #include #include #include #include #include #include #include #include namespace boost { namespace asio { template std::size_t buffered_read_stream::fill() { detail::buffer_resize_guard resize_guard(storage_); std::size_t previous_size = storage_.size(); storage_.resize(storage_.capacity()); storage_.resize(previous_size + next_layer_.read_some(buffer( storage_.data() + previous_size, storage_.size() - previous_size))); resize_guard.commit(); return storage_.size() - previous_size; } template std::size_t buffered_read_stream::fill(boost::system::error_code& ec) { detail::buffer_resize_guard resize_guard(storage_); std::size_t previous_size = storage_.size(); storage_.resize(storage_.capacity()); storage_.resize(previous_size + next_layer_.read_some(buffer( storage_.data() + previous_size, storage_.size() - previous_size), ec)); resize_guard.commit(); return storage_.size() - previous_size; } namespace detail { template class buffered_fill_handler { public: buffered_fill_handler(detail::buffered_stream_storage& storage, std::size_t previous_size, ReadHandler& handler) : storage_(storage), previous_size_(previous_size), handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)) { } #if defined(BOOST_ASIO_HAS_MOVE) buffered_fill_handler(const buffered_fill_handler& other) : storage_(other.storage_), previous_size_(other.previous_size_), handler_(other.handler_) { } buffered_fill_handler(buffered_fill_handler&& other) : storage_(other.storage_), previous_size_(other.previous_size_), handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()(const boost::system::error_code& ec, const std::size_t bytes_transferred) { storage_.resize(previous_size_ + bytes_transferred); handler_(ec, bytes_transferred); } //private: detail::buffered_stream_storage& storage_; std::size_t previous_size_; ReadHandler handler_; }; template inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, buffered_fill_handler* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, buffered_fill_handler* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline bool asio_handler_is_continuation( buffered_fill_handler* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, buffered_fill_handler* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, buffered_fill_handler* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template class initiate_async_buffered_fill { public: typedef typename remove_reference< Stream>::type::lowest_layer_type::executor_type executor_type; explicit initiate_async_buffered_fill( typename remove_reference::type& next_layer) : next_layer_(next_layer) { } executor_type get_executor() const BOOST_ASIO_NOEXCEPT { return next_layer_.lowest_layer().get_executor(); } template void operator()(BOOST_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. BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; non_const_lvalue 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::type>( *storage, previous_size, handler2.value)); } private: typename remove_reference::type& next_layer_; }; } // namespace detail #if !defined(GENERATING_DOCUMENTATION) template struct associated_allocator< detail::buffered_fill_handler, Allocator> { typedef typename associated_allocator::type type; static type get(const detail::buffered_fill_handler& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator::get(h.handler_, a); } }; template struct associated_executor< detail::buffered_fill_handler, Executor> : detail::associated_executor_forwarding_base { typedef typename associated_executor::type type; static type get(const detail::buffered_fill_handler& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor::get(h.handler_, ex); } }; #endif // !defined(GENERATING_DOCUMENTATION) template template < BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, std::size_t)) ReadHandler> BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (boost::system::error_code, std::size_t)) buffered_read_stream::async_fill( BOOST_ASIO_MOVE_ARG(ReadHandler) handler) { return async_initiate( detail::initiate_async_buffered_fill(next_layer_), handler, &storage_); } template template std::size_t buffered_read_stream::read_some( const MutableBufferSequence& buffers) { using boost::asio::buffer_size; if (buffer_size(buffers) == 0) return 0; if (storage_.empty()) this->fill(); return this->copy(buffers); } template template std::size_t buffered_read_stream::read_some( const MutableBufferSequence& buffers, boost::system::error_code& ec) { ec = boost::system::error_code(); using boost::asio::buffer_size; if (buffer_size(buffers) == 0) return 0; if (storage_.empty() && !this->fill(ec)) return 0; return this->copy(buffers); } namespace detail { template class buffered_read_some_handler { public: buffered_read_some_handler(detail::buffered_stream_storage& storage, const MutableBufferSequence& buffers, ReadHandler& handler) : storage_(storage), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)) { } #if defined(BOOST_ASIO_HAS_MOVE) buffered_read_some_handler(const buffered_read_some_handler& other) : storage_(other.storage_), buffers_(other.buffers_), handler_(other.handler_) { } buffered_read_some_handler(buffered_read_some_handler&& other) : storage_(other.storage_), buffers_(other.buffers_), handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()(const boost::system::error_code& ec, std::size_t) { if (ec || storage_.empty()) { const std::size_t length = 0; handler_(ec, length); } else { const std::size_t bytes_copied = boost::asio::buffer_copy( buffers_, storage_.data(), storage_.size()); storage_.consume(bytes_copied); handler_(ec, bytes_copied); } } //private: detail::buffered_stream_storage& storage_; MutableBufferSequence buffers_; ReadHandler handler_; }; template inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, buffered_read_some_handler< MutableBufferSequence, ReadHandler>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, buffered_read_some_handler< MutableBufferSequence, ReadHandler>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline bool asio_handler_is_continuation( buffered_read_some_handler< MutableBufferSequence, ReadHandler>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, buffered_read_some_handler< MutableBufferSequence, ReadHandler>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, buffered_read_some_handler< MutableBufferSequence, ReadHandler>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template class initiate_async_buffered_read_some { public: typedef typename remove_reference< Stream>::type::lowest_layer_type::executor_type executor_type; explicit initiate_async_buffered_read_some( typename remove_reference::type& next_layer) : next_layer_(next_layer) { } executor_type get_executor() const BOOST_ASIO_NOEXCEPT { return next_layer_.lowest_layer().get_executor(); } template void operator()(BOOST_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. BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; using boost::asio::buffer_size; non_const_lvalue handler2(handler); if (buffer_size(buffers) == 0 || !storage->empty()) { next_layer_.async_read_some(BOOST_ASIO_MUTABLE_BUFFER(0, 0), buffered_read_some_handler::type>( *storage, buffers, handler2.value)); } else { initiate_async_buffered_fill(this->next_layer_)( buffered_read_some_handler::type>( *storage, buffers, handler2.value), storage); } } private: typename remove_reference::type& next_layer_; }; } // namespace detail #if !defined(GENERATING_DOCUMENTATION) template struct associated_allocator< detail::buffered_read_some_handler, Allocator> { typedef typename associated_allocator::type type; static type get( const detail::buffered_read_some_handler< MutableBufferSequence, ReadHandler>& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator::get(h.handler_, a); } }; template struct associated_executor< detail::buffered_read_some_handler, Executor> : detail::associated_executor_forwarding_base { typedef typename associated_executor::type type; static type get( const detail::buffered_read_some_handler< MutableBufferSequence, ReadHandler>& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor::get(h.handler_, ex); } }; #endif // !defined(GENERATING_DOCUMENTATION) template template BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler, void (boost::system::error_code, std::size_t)) buffered_read_stream::async_read_some( const MutableBufferSequence& buffers, BOOST_ASIO_MOVE_ARG(ReadHandler) handler) { return async_initiate( detail::initiate_async_buffered_read_some(next_layer_), handler, &storage_, buffers); } template template std::size_t buffered_read_stream::peek( const MutableBufferSequence& buffers) { if (storage_.empty()) this->fill(); return this->peek_copy(buffers); } template template std::size_t buffered_read_stream::peek( const MutableBufferSequence& buffers, boost::system::error_code& ec) { ec = boost::system::error_code(); if (storage_.empty() && !this->fill(ec)) return 0; return this->peek_copy(buffers); } } // namespace asio } // namespace boost #include #endif // BOOST_ASIO_IMPL_BUFFERED_READ_STREAM_HPP