// impl/write_at.hpp
// ~~~~~~~~~~~~~~~~~
//
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include <boost/asio/associated_allocator.hpp>
-#include <boost/asio/associated_executor.hpp>
+#include <boost/asio/associator.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/completion_condition.hpp>
#include <boost/asio/detail/array_fwd.hpp>
+#include <boost/asio/detail/base_from_cancellation_state.hpp>
#include <boost/asio/detail/base_from_completion_cond.hpp>
#include <boost/asio/detail/bind_handler.hpp>
#include <boost/asio/detail/consuming_buffers.hpp>
typename ConstBufferSequence, typename ConstBufferIterator,
typename CompletionCondition, typename WriteHandler>
class write_at_op
- : detail::base_from_completion_cond<CompletionCondition>
+ : public base_from_cancellation_state<WriteHandler>,
+ base_from_completion_cond<CompletionCondition>
{
public:
write_at_op(AsyncRandomAccessWriteDevice& device,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition& completion_condition, WriteHandler& handler)
- : detail::base_from_completion_cond<
- CompletionCondition>(completion_condition),
+ : base_from_cancellation_state<WriteHandler>(
+ handler, enable_partial_cancellation()),
+ base_from_completion_cond<CompletionCondition>(completion_condition),
device_(device),
offset_(offset),
buffers_(buffers),
#if defined(BOOST_ASIO_HAS_MOVE)
write_at_op(const write_at_op& other)
- : detail::base_from_completion_cond<CompletionCondition>(other),
+ : base_from_cancellation_state<WriteHandler>(other),
+ base_from_completion_cond<CompletionCondition>(other),
device_(other.device_),
offset_(other.offset_),
buffers_(other.buffers_),
}
write_at_op(write_at_op&& other)
- : detail::base_from_completion_cond<CompletionCondition>(
- BOOST_ASIO_MOVE_CAST(detail::base_from_completion_cond<
+ : base_from_cancellation_state<WriteHandler>(
+ BOOST_ASIO_MOVE_CAST(base_from_cancellation_state<
+ WriteHandler>)(other)),
+ base_from_completion_cond<CompletionCondition>(
+ BOOST_ASIO_MOVE_CAST(base_from_completion_cond<
CompletionCondition>)(other)),
device_(other.device_),
offset_(other.offset_),
}
#endif // defined(BOOST_ASIO_HAS_MOVE)
- void operator()(const boost::system::error_code& ec,
+ void operator()(boost::system::error_code ec,
std::size_t bytes_transferred, int start = 0)
{
std::size_t max_size;
{
case 1:
max_size = this->check_for_completion(ec, buffers_.total_consumed());
- do
+ for (;;)
{
{
BOOST_ASIO_HANDLER_LOCATION((__FILE__, __LINE__, "async_write_at"));
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 = boost::asio::error::operation_aborted;
+ break;
+ }
+ }
- handler_(ec, buffers_.total_consumed());
+ BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(
+ static_cast<const boost::system::error_code&>(ec),
+ static_cast<const std::size_t&>(buffers_.total_consumed()));
}
}
#if !defined(GENERATING_DOCUMENTATION)
-template <typename AsyncRandomAccessWriteDevice,
- typename ConstBufferSequence, typename ConstBufferIterator,
- typename CompletionCondition, typename WriteHandler, typename Allocator>
-struct associated_allocator<
- detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
- ConstBufferIterator, CompletionCondition, WriteHandler>,
- Allocator>
-{
- typedef typename associated_allocator<WriteHandler, Allocator>::type type;
-
- static type get(
- const detail::write_at_op<AsyncRandomAccessWriteDevice,
- ConstBufferSequence, ConstBufferIterator,
- CompletionCondition, WriteHandler>& h,
- const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT
- {
- return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
- }
-};
-
-template <typename AsyncRandomAccessWriteDevice,
- typename ConstBufferSequence, typename ConstBufferIterator,
- typename CompletionCondition, typename WriteHandler, typename Executor>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+ typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
+ typename ConstBufferIterator, typename CompletionCondition,
+ typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
ConstBufferIterator, CompletionCondition, WriteHandler>,
- Executor>
- : detail::associated_executor_forwarding_base<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::write_at_op<AsyncRandomAccessWriteDevice,
ConstBufferSequence, ConstBufferIterator,
CompletionCondition, WriteHandler>& h,
- const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT
+ const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
{
- return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
+ return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
}
};
template <typename AsyncRandomAccessWriteDevice,
typename ConstBufferSequence, typename CompletionCondition,
BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
- std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+ std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
void (boost::system::error_code, std::size_t))
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
CompletionCondition completion_condition,
- BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+ BOOST_ASIO_MOVE_ARG(WriteToken) token)
{
- return async_initiate<WriteHandler,
+ return async_initiate<WriteToken,
void (boost::system::error_code, std::size_t)>(
detail::initiate_async_write_at_buffer_sequence<
AsyncRandomAccessWriteDevice>(d),
- handler, offset, buffers,
+ token, offset, buffers,
BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
}
template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
- std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+ std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
void (boost::system::error_code, std::size_t))
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, const ConstBufferSequence& buffers,
- BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+ BOOST_ASIO_MOVE_ARG(WriteToken) token)
{
- return async_initiate<WriteHandler,
+ return async_initiate<WriteToken,
void (boost::system::error_code, std::size_t)>(
detail::initiate_async_write_at_buffer_sequence<
AsyncRandomAccessWriteDevice>(d),
- handler, offset, buffers, transfer_all());
+ token, offset, buffers, transfer_all());
}
#if !defined(BOOST_ASIO_NO_EXTENSIONS)
const std::size_t bytes_transferred)
{
streambuf_.consume(bytes_transferred);
- handler_(ec, bytes_transferred);
+ BOOST_ASIO_MOVE_OR_LVALUE(WriteHandler)(handler_)(ec, bytes_transferred);
}
//private:
#if !defined(GENERATING_DOCUMENTATION)
-template <typename Allocator, typename WriteHandler, typename Allocator1>
-struct associated_allocator<
- detail::write_at_streambuf_op<Allocator, WriteHandler>,
- Allocator1>
-{
- typedef typename associated_allocator<WriteHandler, Allocator1>::type type;
-
- static type get(
- const detail::write_at_streambuf_op<Allocator, WriteHandler>& h,
- const Allocator1& a = Allocator1()) BOOST_ASIO_NOEXCEPT
- {
- return associated_allocator<WriteHandler, Allocator1>::get(h.handler_, a);
- }
-};
-
-template <typename Executor, typename WriteHandler, typename Executor1>
-struct associated_executor<
+template <template <typename, typename> class Associator,
+ typename Executor, typename WriteHandler, typename DefaultCandidate>
+struct associator<Associator,
detail::write_at_streambuf_op<Executor, WriteHandler>,
- Executor1>
- : detail::associated_executor_forwarding_base<WriteHandler, Executor>
+ DefaultCandidate>
+ : Associator<WriteHandler, DefaultCandidate>
{
- typedef typename associated_executor<WriteHandler, Executor1>::type type;
-
- static type get(
+ static typename Associator<WriteHandler, DefaultCandidate>::type get(
const detail::write_at_streambuf_op<Executor, WriteHandler>& h,
- const Executor1& ex = Executor1()) BOOST_ASIO_NOEXCEPT
+ const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
{
- return associated_executor<WriteHandler, Executor1>::get(h.handler_, ex);
+ return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
}
};
template <typename AsyncRandomAccessWriteDevice,
typename Allocator, typename CompletionCondition,
BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
- std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+ std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
void (boost::system::error_code, std::size_t))
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
CompletionCondition completion_condition,
- BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+ BOOST_ASIO_MOVE_ARG(WriteToken) token)
{
- return async_initiate<WriteHandler,
+ return async_initiate<WriteToken,
void (boost::system::error_code, std::size_t)>(
detail::initiate_async_write_at_streambuf<
AsyncRandomAccessWriteDevice>(d),
- handler, offset, &b,
+ token, offset, &b,
BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition));
}
template <typename AsyncRandomAccessWriteDevice, typename Allocator,
BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
- std::size_t)) WriteHandler>
-inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
+ std::size_t)) WriteToken>
+inline BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
void (boost::system::error_code, std::size_t))
async_write_at(AsyncRandomAccessWriteDevice& d,
uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
- BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+ BOOST_ASIO_MOVE_ARG(WriteToken) token)
{
- return async_initiate<WriteHandler,
+ return async_initiate<WriteToken,
void (boost::system::error_code, std::size_t)>(
detail::initiate_async_write_at_streambuf<
AsyncRandomAccessWriteDevice>(d),
- handler, offset, &b, transfer_all());
+ token, offset, &b, transfer_all());
}
#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
projects / ceph.git / blobdiff