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

   1 //
   2 // Copyright (c) 2016-2019 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_HPP
  11 #define BOOST_BEAST_IMPL_BUFFERED_READ_STREAM_HPP
  12
  13 #include <boost/beast/core/async_base.hpp>
  14 #include <boost/beast/core/bind_handler.hpp>
  15 #include <boost/beast/core/error.hpp>
  16 #include <boost/beast/core/read_size.hpp>
  17 #include <boost/beast/core/stream_traits.hpp>
  18 #include <boost/beast/core/detail/is_invocable.hpp>
  19 #include <boost/asio/post.hpp>
  20 #include <boost/throw_exception.hpp>
  21
  22 namespace boost {
  23 namespace beast {
  24
  25
  26 template<class Stream, class DynamicBuffer>
  27 struct buffered_read_stream<Stream, DynamicBuffer>::ops
  28 {
  29
  30 template<class MutableBufferSequence, class Handler>
  31 class read_op
  32     : public async_base<Handler,
  33     beast::executor_type<buffered_read_stream>>
  34 {
  35     buffered_read_stream& s_;
  36     MutableBufferSequence b_;
  37     int step_ = 0;
  38
  39 public:
  40     read_op(read_op&&) = default;
  41     read_op(read_op const&) = delete;
  42
  43     template<class Handler_>
  44     read_op(
  45         Handler_&& h,
  46         buffered_read_stream& s,
  47         MutableBufferSequence const& b)
  48         : async_base<
  49             Handler, beast::executor_type<buffered_read_stream>>(
  50                 std::forward<Handler_>(h), s.get_executor())
  51         , s_(s)
  52         , b_(b)
  53     {
  54         (*this)({}, 0);
  55     }
  56
  57     void
  58     operator()(
  59         error_code ec,
  60         std::size_t bytes_transferred)
  61     {
  62         // VFALCO TODO Rewrite this using reenter/yield
  63         switch(step_)
  64         {
  65         case 0:
  66             if(s_.buffer_.size() == 0)
  67             {
  68                 if(s_.capacity_ == 0)
  69                 {
  70                     // read (unbuffered)
  71                     step_ = 1;
  72                     return s_.next_layer_.async_read_some(
  73                         b_, std::move(*this));
  74                 }
  75                 // read
  76                 step_ = 2;
  77                 return s_.next_layer_.async_read_some(
  78                     s_.buffer_.prepare(read_size(
  79                         s_.buffer_, s_.capacity_)),
  80                             std::move(*this));
  81             }
  82             step_ = 3;
  83             return net::post(
  84                 s_.get_executor(),
  85                 beast::bind_front_handler(
  86                     std::move(*this), ec, 0));
  87
  88         case 1:
  89             // upcall
  90             break;
  91
  92         case 2:
  93             s_.buffer_.commit(bytes_transferred);
  94             BOOST_FALLTHROUGH;
  95
  96         case 3:
  97             bytes_transferred =
  98                 net::buffer_copy(b_, s_.buffer_.data());
  99             s_.buffer_.consume(bytes_transferred);
 100             break;
 101         }
 102         this->complete_now(ec, bytes_transferred);
 103     }
 104 };
 105
 106 struct run_read_op
 107 {
 108     template<class ReadHandler, class Buffers>
 109     void
 110     operator()(
 111         ReadHandler&& h,
 112         buffered_read_stream* s,
 113         Buffers const& b)
 114     {
 115         // If you get an error on the following line it means
 116         // that your handler does not meet the documented type
 117         // requirements for the handler.
 118
 119         static_assert(
 120             beast::detail::is_invocable<ReadHandler,
 121             void(error_code, std::size_t)>::value,
 122             "ReadHandler type requirements not met");
 123
 124         read_op<
 125             Buffers,
 126             typename std::decay<ReadHandler>::type>(
 127                 std::forward<ReadHandler>(h), *s, b);
 128     }
 129 };
 130
 131 };
 132
 133 //------------------------------------------------------------------------------
 134
 135 template<class Stream, class DynamicBuffer>
 136 template<class... Args>
 137 buffered_read_stream<Stream, DynamicBuffer>::
 138 buffered_read_stream(Args&&... args)
 139     : next_layer_(std::forward<Args>(args)...)
 140 {
 141 }
 142
 143 template<class Stream, class DynamicBuffer>
 144 template<class ConstBufferSequence, class WriteHandler>
 145 BOOST_BEAST_ASYNC_RESULT2(WriteHandler)
 146 buffered_read_stream<Stream, DynamicBuffer>::
 147 async_write_some(
 148     ConstBufferSequence const& buffers,
 149     WriteHandler&& handler)
 150 {
 151     static_assert(is_async_write_stream<next_layer_type>::value,
 152         "AsyncWriteStream type requirements not met");
 153     static_assert(net::is_const_buffer_sequence<
 154         ConstBufferSequence>::value,
 155             "ConstBufferSequence type requirements not met");
 156     static_assert(detail::is_invocable<WriteHandler,
 157         void(error_code, std::size_t)>::value,
 158             "WriteHandler type requirements not met");
 159     return next_layer_.async_write_some(buffers,
 160         std::forward<WriteHandler>(handler));
 161 }
 162
 163 template<class Stream, class DynamicBuffer>
 164 template<class MutableBufferSequence>
 165 std::size_t
 166 buffered_read_stream<Stream, DynamicBuffer>::
 167 read_some(
 168     MutableBufferSequence const& buffers)
 169 {
 170     static_assert(is_sync_read_stream<next_layer_type>::value,
 171         "SyncReadStream type requirements not met");
 172     static_assert(net::is_mutable_buffer_sequence<
 173         MutableBufferSequence>::value,
 174             "MutableBufferSequence type requirements not met");
 175     error_code ec;
 176     auto n = read_some(buffers, ec);
 177     if(ec)
 178         BOOST_THROW_EXCEPTION(system_error{ec});
 179     return n;
 180 }
 181
 182 template<class Stream, class DynamicBuffer>
 183 template<class MutableBufferSequence>
 184 std::size_t
 185 buffered_read_stream<Stream, DynamicBuffer>::
 186 read_some(MutableBufferSequence const& buffers,
 187     error_code& ec)
 188 {
 189     static_assert(is_sync_read_stream<next_layer_type>::value,
 190         "SyncReadStream type requirements not met");
 191     static_assert(net::is_mutable_buffer_sequence<
 192         MutableBufferSequence>::value,
 193             "MutableBufferSequence type requirements not met");
 194     if(buffer_.size() == 0)
 195     {
 196         if(capacity_ == 0)
 197             return next_layer_.read_some(buffers, ec);
 198         buffer_.commit(next_layer_.read_some(
 199             buffer_.prepare(read_size(buffer_,
 200                 capacity_)), ec));
 201         if(ec)
 202             return 0;
 203     }
 204     else
 205     {
 206         ec = {};
 207     }
 208     auto bytes_transferred =
 209         net::buffer_copy(buffers, buffer_.data());
 210     buffer_.consume(bytes_transferred);
 211     return bytes_transferred;
 212 }
 213
 214 template<class Stream, class DynamicBuffer>
 215 template<class MutableBufferSequence, class ReadHandler>
 216 BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
 217 buffered_read_stream<Stream, DynamicBuffer>::
 218 async_read_some(
 219     MutableBufferSequence const& buffers,
 220     ReadHandler&& handler)
 221 {
 222     static_assert(is_async_read_stream<next_layer_type>::value,
 223         "AsyncReadStream type requirements not met");
 224     static_assert(net::is_mutable_buffer_sequence<
 225         MutableBufferSequence>::value,
 226             "MutableBufferSequence type requirements not met");
 227     if(buffer_.size() == 0 && capacity_ == 0)
 228         return next_layer_.async_read_some(buffers,
 229             std::forward<ReadHandler>(handler));
 230     return net::async_initiate<
 231         ReadHandler,
 232         void(error_code, std::size_t)>(
 233             typename ops::run_read_op{},
 234             handler,
 235             this,
 236             buffers);
 237 }
 238
 239 } // beast
 240 } // boost
 241
 242 #endif