summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/include/asio/impl/buffered_write_stream.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/include/asio/impl/buffered_write_stream.hpp')
-rw-r--r--3rdparty/asio/include/asio/impl/buffered_write_stream.hpp286
1 files changed, 179 insertions, 107 deletions
diff --git a/3rdparty/asio/include/asio/impl/buffered_write_stream.hpp b/3rdparty/asio/include/asio/impl/buffered_write_stream.hpp
index 4ce6e5ebf04..efb30a684c9 100644
--- a/3rdparty/asio/include/asio/impl/buffered_write_stream.hpp
+++ b/3rdparty/asio/include/asio/impl/buffered_write_stream.hpp
@@ -2,7 +2,7 @@
// impl/buffered_write_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,12 @@
# 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/push_options.hpp"
@@ -76,7 +76,7 @@ namespace detail
const std::size_t bytes_written)
{
storage_.consume(bytes_written);
- handler_(ec, bytes_written);
+ ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_written);
}
//private:
@@ -85,19 +85,29 @@ namespace detail
};
template <typename WriteHandler>
- inline void* asio_handler_allocate(std::size_t size,
+ inline asio_handler_allocate_is_deprecated
+ asio_handler_allocate(std::size_t size,
buffered_flush_handler<WriteHandler>* 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 WriteHandler>
- 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_flush_handler<WriteHandler>* 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 WriteHandler>
@@ -109,72 +119,98 @@ namespace detail
}
template <typename Function, typename WriteHandler>
- inline void asio_handler_invoke(Function& function,
+ inline asio_handler_invoke_is_deprecated
+ asio_handler_invoke(Function& function,
buffered_flush_handler<WriteHandler>* 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 WriteHandler>
- inline void asio_handler_invoke(const Function& function,
+ inline asio_handler_invoke_is_deprecated
+ asio_handler_invoke(const Function& function,
buffered_flush_handler<WriteHandler>* 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_flush
+ {
+ public:
+ typedef typename remove_reference<
+ Stream>::type::lowest_layer_type::executor_type executor_type;
-template <typename WriteHandler, typename Allocator>
-struct associated_allocator<
- detail::buffered_flush_handler<WriteHandler>, Allocator>
-{
- typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+ explicit initiate_async_buffered_flush(
+ typename remove_reference<Stream>::type& next_layer)
+ : next_layer_(next_layer)
+ {
+ }
- static type get(const detail::buffered_flush_handler<WriteHandler>& h,
- const Allocator& a = Allocator()) ASIO_NOEXCEPT
- {
- return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
- }
-};
+ executor_type get_executor() const ASIO_NOEXCEPT
+ {
+ return next_layer_.lowest_layer().get_executor();
+ }
-template <typename WriteHandler, typename Executor>
-struct associated_executor<
- detail::buffered_flush_handler<WriteHandler>, Executor>
-{
- typedef typename associated_executor<WriteHandler, Executor>::type type;
+ template <typename WriteHandler>
+ void operator()(ASIO_MOVE_ARG(WriteHandler) 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 WriteHandler.
+ ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+ non_const_lvalue<WriteHandler> handler2(handler);
+ async_write(next_layer_, buffer(storage->data(), storage->size()),
+ buffered_flush_handler<typename decay<WriteHandler>::type>(
+ *storage, handler2.value));
+ }
+
+ private:
+ typename remove_reference<Stream>::type& next_layer_;
+ };
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
- static type get(const detail::buffered_flush_handler<WriteHandler>& h,
- const Executor& ex = Executor()) ASIO_NOEXCEPT
+template <template <typename, typename> class Associator,
+ typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
+ detail::buffered_flush_handler<WriteHandler>,
+ DefaultCandidate>
+ : Associator<WriteHandler, DefaultCandidate>
+{
+ static typename Associator<WriteHandler, DefaultCandidate>::type get(
+ const detail::buffered_flush_handler<WriteHandler>& h,
+ const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT
{
- return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+ return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
}
};
#endif // !defined(GENERATING_DOCUMENTATION)
template <typename Stream>
-template <typename WriteHandler>
-ASIO_INITFN_RESULT_TYPE(WriteHandler,
+template <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ std::size_t)) WriteHandler>
+ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
void (asio::error_code, std::size_t))
buffered_write_stream<Stream>::async_flush(
ASIO_MOVE_ARG(WriteHandler) handler)
{
- // 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);
-
- async_write(next_layer_, buffer(storage_.data(), storage_.size()),
- detail::buffered_flush_handler<ASIO_HANDLER_TYPE(
- WriteHandler, void (asio::error_code, std::size_t))>(
- storage_, init.completion_handler));
-
- return init.result.get();
+ return async_initiate<WriteHandler,
+ void (asio::error_code, std::size_t)>(
+ detail::initiate_async_buffered_flush<Stream>(next_layer_),
+ handler, &storage_);
}
template <typename Stream>
@@ -182,7 +218,8 @@ template <typename ConstBufferSequence>
std::size_t buffered_write_stream<Stream>::write_some(
const ConstBufferSequence& buffers)
{
- if (asio::buffer_size(buffers) == 0)
+ using asio::buffer_size;
+ if (buffer_size(buffers) == 0)
return 0;
if (storage_.size() == storage_.capacity())
@@ -198,7 +235,8 @@ std::size_t buffered_write_stream<Stream>::write_some(
{
ec = asio::error_code();
- if (asio::buffer_size(buffers) == 0)
+ using asio::buffer_size;
+ if (buffer_size(buffers) == 0)
return 0;
if (storage_.size() == storage_.capacity() && !flush(ec))
@@ -242,19 +280,20 @@ namespace detail
if (ec)
{
const std::size_t length = 0;
- handler_(ec, length);
+ ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, length);
}
else
{
+ using asio::buffer_size;
std::size_t orig_size = storage_.size();
std::size_t space_avail = storage_.capacity() - orig_size;
- std::size_t bytes_avail = asio::buffer_size(buffers_);
+ std::size_t bytes_avail = buffer_size(buffers_);
std::size_t length = bytes_avail < space_avail
? bytes_avail : space_avail;
storage_.resize(orig_size + length);
const std::size_t bytes_copied = asio::buffer_copy(
storage_.data() + orig_size, buffers_, length);
- handler_(ec, bytes_copied);
+ ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_copied);
}
}
@@ -265,21 +304,31 @@ namespace detail
};
template <typename ConstBufferSequence, typename WriteHandler>
- inline void* asio_handler_allocate(std::size_t size,
+ inline asio_handler_allocate_is_deprecated
+ asio_handler_allocate(std::size_t size,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* 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 ConstBufferSequence, typename WriteHandler>
- 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_write_some_handler<
ConstBufferSequence, WriteHandler>* 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 ConstBufferSequence, typename WriteHandler>
@@ -293,96 +342,118 @@ namespace detail
template <typename Function, typename ConstBufferSequence,
typename WriteHandler>
- inline void asio_handler_invoke(Function& function,
+ inline asio_handler_invoke_is_deprecated
+ asio_handler_invoke(Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* 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 ConstBufferSequence,
typename WriteHandler>
- inline void asio_handler_invoke(const Function& function,
+ inline asio_handler_invoke_is_deprecated
+ asio_handler_invoke(const Function& function,
buffered_write_some_handler<
ConstBufferSequence, WriteHandler>* 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_write_some
+ {
+ public:
+ typedef typename remove_reference<
+ Stream>::type::lowest_layer_type::executor_type executor_type;
-template <typename ConstBufferSequence,
- typename WriteHandler, typename Allocator>
-struct associated_allocator<
- detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
- Allocator>
-{
- typedef typename associated_allocator<WriteHandler, Allocator>::type type;
+ explicit initiate_async_buffered_write_some(
+ typename remove_reference<Stream>::type& next_layer)
+ : next_layer_(next_layer)
+ {
+ }
- static type get(
- const detail::buffered_write_some_handler<
- ConstBufferSequence, WriteHandler>& h,
- const Allocator& a = Allocator()) ASIO_NOEXCEPT
- {
- return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
- }
-};
+ executor_type get_executor() const ASIO_NOEXCEPT
+ {
+ return next_layer_.lowest_layer().get_executor();
+ }
-template <typename ConstBufferSequence,
- typename WriteHandler, typename Executor>
-struct associated_executor<
+ template <typename WriteHandler, typename ConstBufferSequence>
+ void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
+ buffered_stream_storage* storage,
+ const ConstBufferSequence& 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 WriteHandler.
+ ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
+
+ using asio::buffer_size;
+ non_const_lvalue<WriteHandler> handler2(handler);
+ if (buffer_size(buffers) == 0 || storage->size() < storage->capacity())
+ {
+ next_layer_.async_write_some(ASIO_CONST_BUFFER(0, 0),
+ buffered_write_some_handler<ConstBufferSequence,
+ typename decay<WriteHandler>::type>(
+ *storage, buffers, handler2.value));
+ }
+ else
+ {
+ initiate_async_buffered_flush<Stream>(this->next_layer_)(
+ buffered_write_some_handler<ConstBufferSequence,
+ typename decay<WriteHandler>::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 ConstBufferSequence, typename WriteHandler,
+ typename DefaultCandidate>
+struct associator<Associator,
detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
- Executor>
+ DefaultCandidate>
+ : Associator<WriteHandler, DefaultCandidate>
{
- typedef typename associated_executor<WriteHandler, Executor>::type type;
-
- static type get(
+ static typename Associator<WriteHandler, DefaultCandidate>::type get(
const detail::buffered_write_some_handler<
ConstBufferSequence, WriteHandler>& h,
- const Executor& ex = Executor()) ASIO_NOEXCEPT
+ const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT
{
- return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+ return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
}
};
#endif // !defined(GENERATING_DOCUMENTATION)
template <typename Stream>
-template <typename ConstBufferSequence, typename WriteHandler>
-ASIO_INITFN_RESULT_TYPE(WriteHandler,
+template <typename ConstBufferSequence,
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ std::size_t)) WriteHandler>
+ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
void (asio::error_code, std::size_t))
buffered_write_stream<Stream>::async_write_some(
const ConstBufferSequence& buffers,
ASIO_MOVE_ARG(WriteHandler) handler)
{
- // 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);
-
- if (asio::buffer_size(buffers) == 0
- || storage_.size() < storage_.capacity())
- {
- next_layer_.async_write_some(ASIO_CONST_BUFFER(0, 0),
- detail::buffered_write_some_handler<
- ConstBufferSequence, ASIO_HANDLER_TYPE(
- WriteHandler, void (asio::error_code, std::size_t))>(
- storage_, buffers, init.completion_handler));
- }
- else
- {
- this->async_flush(detail::buffered_write_some_handler<
- ConstBufferSequence, ASIO_HANDLER_TYPE(
- WriteHandler, void (asio::error_code, std::size_t))>(
- storage_, buffers, init.completion_handler));
- }
-
- return init.result.get();
+ return async_initiate<WriteHandler,
+ void (asio::error_code, std::size_t)>(
+ detail::initiate_async_buffered_write_some<Stream>(next_layer_),
+ handler, &storage_, buffers);
}
template <typename Stream>
@@ -390,9 +461,10 @@ template <typename ConstBufferSequence>
std::size_t buffered_write_stream<Stream>::copy(
const ConstBufferSequence& buffers)
{
+ using asio::buffer_size;
std::size_t orig_size = storage_.size();
std::size_t space_avail = storage_.capacity() - orig_size;
- std::size_t bytes_avail = asio::buffer_size(buffers);
+ std::size_t bytes_avail = buffer_size(buffers);
std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
storage_.resize(orig_size + length);
return asio::buffer_copy(