ceph/src/boost/boost/beast/core/impl/buffered_read_stream.ipp

   1 //
   2 // Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
   3 //
   4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // Official repository: https://github.com/boostorg/beast
   8 //
   9
  10 #ifndef BOOST_BEAST_IMPL_BUFFERED_READ_STREAM_IPP
  11 #define BOOST_BEAST_IMPL_BUFFERED_READ_STREAM_IPP
  12
  13 #include <boost/beast/core/bind_handler.hpp>
  14 #include <boost/beast/core/error.hpp>
  15 #include <boost/beast/core/handler_ptr.hpp>
  16 #include <boost/beast/core/read_size.hpp>
  17 #include <boost/beast/core/type_traits.hpp>
  18 #include <boost/beast/core/detail/config.hpp>
  19 #include <boost/asio/associated_allocator.hpp>
  20 #include <boost/asio/associated_executor.hpp>
  21 #include <boost/asio/handler_continuation_hook.hpp>
  22 #include <boost/asio/post.hpp>
  23 #include <boost/throw_exception.hpp>
  24
  25 namespace boost {
  26 namespace beast {
  27
  28 template<class Stream, class DynamicBuffer>
  29 template<class MutableBufferSequence, class Handler>
  30 class buffered_read_stream<
  31     Stream, DynamicBuffer>::read_some_op
  32 {
  33     int step_ = 0;
  34     buffered_read_stream& s_;
  35     MutableBufferSequence b_;
  36     Handler h_;
  37
  38 public:
  39     read_some_op(read_some_op&&) = default;
  40     read_some_op(read_some_op const&) = default;
  41
  42     template<class DeducedHandler, class... Args>
  43     read_some_op(DeducedHandler&& h,
  44         buffered_read_stream& s,
  45             MutableBufferSequence const& b)
  46         : s_(s)
  47         , b_(b)
  48         , h_(std::forward<DeducedHandler>(h))
  49     {
  50     }
  51
  52     using allocator_type =
  53         boost::asio::associated_allocator_t<Handler>;
  54
  55     allocator_type
  56     get_allocator() const noexcept
  57     {
  58         return boost::asio::get_associated_allocator(h_);
  59     }
  60
  61     using executor_type =
  62         boost::asio::associated_executor_t<Handler, decltype(
  63             std::declval<buffered_read_stream&>().get_executor())>;
  64
  65     executor_type
  66     get_executor() const noexcept
  67     {
  68         return boost::asio::get_associated_executor(
  69             h_, s_.get_executor());
  70     }
  71
  72     void
  73     operator()(error_code const& ec,
  74         std::size_t bytes_transferred);
  75
  76     friend
  77     bool asio_handler_is_continuation(read_some_op* op)
  78     {
  79         using boost::asio::asio_handler_is_continuation;
  80         return asio_handler_is_continuation(
  81             std::addressof(op->h_));
  82     }
  83 };
  84
  85 template<class Stream, class DynamicBuffer>
  86 template<class MutableBufferSequence, class Handler>
  87 void
  88 buffered_read_stream<Stream, DynamicBuffer>::
  89 read_some_op<MutableBufferSequence, Handler>::operator()(
  90     error_code const& ec, std::size_t bytes_transferred)
  91 {
  92     switch(step_)
  93     {
  94     case 0:
  95         if(s_.buffer_.size() == 0)
  96         {
  97             if(s_.capacity_ == 0)
  98             {
  99                 // read (unbuffered)
 100                 step_ = 1;
 101                 return s_.next_layer_.async_read_some(
 102                     b_, std::move(*this));
 103             }
 104
 105             // read
 106             step_ = 2;
 107             return s_.next_layer_.async_read_some(
 108                 s_.buffer_.prepare(read_size(
 109                     s_.buffer_, s_.capacity_)),
 110                         std::move(*this));
 111
 112         }
 113         step_ = 3;
 114         return boost::asio::post(
 115             s_.get_executor(),
 116             bind_handler(std::move(*this), ec, 0));
 117
 118     case 1:
 119         // upcall
 120         break;
 121
 122     case 2:
 123         s_.buffer_.commit(bytes_transferred);
 124         BOOST_BEAST_FALLTHROUGH;
 125
 126     case 3:
 127         bytes_transferred =
 128             boost::asio::buffer_copy(b_, s_.buffer_.data());
 129         s_.buffer_.consume(bytes_transferred);
 130         break;
 131     }
 132     h_(ec, bytes_transferred);
 133 }
 134
 135 //------------------------------------------------------------------------------
 136
 137 template<class Stream, class DynamicBuffer>
 138 template<class... Args>
 139 buffered_read_stream<Stream, DynamicBuffer>::
 140 buffered_read_stream(Args&&... args)
 141     : next_layer_(std::forward<Args>(args)...)
 142 {
 143 }
 144
 145 template<class Stream, class DynamicBuffer>
 146 template<class ConstBufferSequence, class WriteHandler>
 147 BOOST_ASIO_INITFN_RESULT_TYPE(
 148     WriteHandler, void(error_code, std::size_t))
 149 buffered_read_stream<Stream, DynamicBuffer>::
 150 async_write_some(
 151     ConstBufferSequence const& buffers,
 152     WriteHandler&& handler)
 153 {
 154     static_assert(is_async_write_stream<next_layer_type>::value,
 155         "AsyncWriteStream requirements not met");
 156     static_assert(boost::asio::is_const_buffer_sequence<
 157         ConstBufferSequence>::value,
 158             "ConstBufferSequence requirements not met");
 159     static_assert(is_completion_handler<WriteHandler,
 160         void(error_code, std::size_t)>::value,
 161             "WriteHandler requirements not met");
 162     return next_layer_.async_write_some(buffers,
 163         std::forward<WriteHandler>(handler));
 164 }
 165
 166 template<class Stream, class DynamicBuffer>
 167 template<class MutableBufferSequence>
 168 std::size_t
 169 buffered_read_stream<Stream, DynamicBuffer>::
 170 read_some(
 171     MutableBufferSequence const& buffers)
 172 {
 173     static_assert(is_sync_read_stream<next_layer_type>::value,
 174         "SyncReadStream requirements not met");
 175     static_assert(boost::asio::is_mutable_buffer_sequence<
 176         MutableBufferSequence>::value,
 177             "MutableBufferSequence requirements not met");
 178     error_code ec;
 179     auto n = read_some(buffers, ec);
 180     if(ec)
 181         BOOST_THROW_EXCEPTION(system_error{ec});
 182     return n;
 183 }
 184
 185 template<class Stream, class DynamicBuffer>
 186 template<class MutableBufferSequence>
 187 std::size_t
 188 buffered_read_stream<Stream, DynamicBuffer>::
 189 read_some(MutableBufferSequence const& buffers,
 190     error_code& ec)
 191 {
 192     static_assert(is_sync_read_stream<next_layer_type>::value,
 193         "SyncReadStream requirements not met");
 194     static_assert(boost::asio::is_mutable_buffer_sequence<
 195         MutableBufferSequence>::value,
 196             "MutableBufferSequence requirements not met");
 197     using boost::asio::buffer_size;
 198     using boost::asio::buffer_copy;
 199     if(buffer_.size() == 0)
 200     {
 201         if(capacity_ == 0)
 202             return next_layer_.read_some(buffers, ec);
 203         buffer_.commit(next_layer_.read_some(
 204             buffer_.prepare(read_size(buffer_,
 205                 capacity_)), ec));
 206         if(ec)
 207             return 0;
 208     }
 209     else
 210     {
 211         ec.assign(0, ec.category());
 212     }
 213     auto bytes_transferred =
 214         buffer_copy(buffers, buffer_.data());
 215     buffer_.consume(bytes_transferred);
 216     return bytes_transferred;
 217 }
 218
 219 template<class Stream, class DynamicBuffer>
 220 template<class MutableBufferSequence, class ReadHandler>
 221 BOOST_ASIO_INITFN_RESULT_TYPE(
 222     ReadHandler, void(error_code, std::size_t))
 223 buffered_read_stream<Stream, DynamicBuffer>::
 224 async_read_some(
 225     MutableBufferSequence const& buffers,
 226     ReadHandler&& handler)
 227 {
 228     static_assert(is_async_read_stream<next_layer_type>::value,
 229         "AsyncReadStream requirements not met");
 230     static_assert(boost::asio::is_mutable_buffer_sequence<
 231         MutableBufferSequence>::value,
 232             "MutableBufferSequence requirements not met");
 233     if(buffer_.size() == 0 && capacity_ == 0)
 234         return next_layer_.async_read_some(buffers,
 235             std::forward<ReadHandler>(handler));
 236     boost::asio::async_completion<ReadHandler,
 237         void(error_code, std::size_t)> init{handler};
 238     read_some_op<MutableBufferSequence, BOOST_ASIO_HANDLER_TYPE(
 239         ReadHandler, void(error_code, std::size_t))>{
 240             init.completion_handler, *this, buffers}(
 241                 error_code{}, 0);
 242     return init.result.get();
 243 }
 244
 245 } // beast
 246 } // boost
 247
 248 #endif