summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/include/asio/impl/buffered_read_stream.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/include/asio/impl/buffered_read_stream.hpp')
-rw-r--r--3rdparty/asio/include/asio/impl/buffered_read_stream.hpp290
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>