New HTTP interfaces (API Change):

fix #123
fix #154
fix #265

This completely replaces the HTTP parser used to read and
parse incoming messages. The new version is faster than
the old one, and written in fewer lines. A summary of
changes:

* parse and async_parse renamed to read and async_read

* basic_parser is optimized for linear buffers,
  use flat_streambuf for the best performance with these
  functions:

  - http::read
  - http::read_some
  - http::async_read
  - http::async_read_some

* The overloads of read() and async_read() which take
  just a header have been removed, since they would
  throw away important parse metadata.

* The derived class callbacks for basic_parser have
  been streamlined. All strings passed to callbacks
  are presented in their entirety, instead of being
  provided in pieces.

These changes allow use-cases that were previously
difficult or impossible, such as:

- Efficient relaying

- Late body type commitment

- Expect: 100-continue handling

include/beast/http/string_body.hpp

@@ -34,29 +34,58 @@ private:
 
     class reader
     {
-        value_type& s_;
+        value_type& body_;
+        std::size_t len_ = 0;
 
     public:
+        static bool constexpr is_direct = true;
+
+        using mutable_buffers_type =
+            boost::asio::mutable_buffers_1;
+
         template<bool isRequest, class Fields>
         explicit
         reader(message<isRequest,
-                string_body, Fields>& m) noexcept
-            : s_(m.body)
+                string_body, Fields>& m)
+            : body_(m.body)
         {
         }
 
         void
-        init(error_code&) noexcept
+        init()
         {
         }
 
         void
-        write(void const* data,
-            std::size_t size, error_code&) noexcept
+        init(std::uint64_t content_length)
         {
-            auto const n = s_.size();
-            s_.resize(n + size);
-            std::memcpy(&s_[n], data, size);
+            if(content_length >
+                    (std::numeric_limits<std::size_t>::max)())
+                throw std::length_error{
+                    "Content-Length overflow"};
+            body_.reserve(static_cast<
+                std::size_t>(content_length));
+        }
+
+        mutable_buffers_type
+        prepare(std::size_t n)
+        {
+            body_.resize(len_ + n);
+            return {&body_[len_], n};
+        }
+
+        void
+        commit(std::size_t n)
+        {
+            if(body_.size() > len_ + n)
+                body_.resize(len_ + n);
+            len_ = body_.size();
+        }
+
+        void
+        finish()
+        {
+            body_.resize(len_);
         }
     };