Rename concept to DynamicBuffer (API change):

Conform to the Networking TS by renaming the Streambuf concept
to DynamicBuffer in all places. Values of types meeting the
requirements of DynamicBuffer are renamed to dynabuf.

See:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4478.html#requirements.dynamic_buffers

* Headers renamed
* Formal parameter names renamed
* Template argument types renamed
* Documentation updated

include/beast/core/impl/basic_streambuf.ipp

@@ -8,7 +8,7 @@
 #ifndef BEAST_IMPL_BASIC_STREAMBUF_IPP
 #define BEAST_IMPL_BASIC_STREAMBUF_IPP
 
-#include <beast/core/detail/write_streambuf.hpp>
+#include <beast/core/detail/write_dynabuf.hpp>
 #include <algorithm>
 #include <cassert>
 #include <exception>
@@ -527,6 +527,28 @@ basic_streambuf<Allocator>::basic_streambuf(
             "basic_streambuf: invalid alloc_size");
 }
 
+template<class Allocator>
+std::size_t
+basic_streambuf<Allocator>::capacity() const
+{
+    auto pos = out_;
+    if(pos == list_.end())
+        return 0;
+    auto n = pos->size() - out_pos_;
+    while(++pos != list_.end())
+        n += pos->size();
+    return in_size_ + n;
+}
+
+template<class Allocator>
+auto
+basic_streambuf<Allocator>::
+data() const ->
+    const_buffers_type
+{
+    return const_buffers_type(*this);
+}
+
 template<class Allocator>
 auto
 basic_streambuf<Allocator>::prepare(size_type n) ->
@@ -646,14 +668,6 @@ basic_streambuf<Allocator>::commit(size_type n)
     debug_check();
 }
 
-template<class Allocator>
-auto
-basic_streambuf<Allocator>::data() const ->
-    const_buffers_type
-{
-    return const_buffers_type(*this);
-}
-
 template<class Allocator>
 void
 basic_streambuf<Allocator>::consume(size_type n)
@@ -717,7 +731,8 @@ basic_streambuf<Allocator>::consume(size_type n)
 
 template<class Allocator>
 void
-basic_streambuf<Allocator>::clear()
+basic_streambuf<Allocator>::
+clear()
 {
     delete_list();
     list_.clear();
@@ -795,21 +810,6 @@ basic_streambuf<Allocator>::delete_list()
     }
 }
 
-// Returns the number of bytes which can be
-// prepared without causing a memory allocation.
-template<class Allocator>
-std::size_t
-basic_streambuf<Allocator>::prepare_size() const
-{
-    auto pos = out_;
-    if(pos == list_.end())
-        return 0;
-    auto n = pos->size() - out_pos_;
-    while(++pos != list_.end())
-        n += pos->size();
-    return n;
-}
-
 template<class Allocator>
 void
 basic_streambuf<Allocator>::debug_check() const
@@ -855,7 +855,7 @@ std::size_t
 read_size_helper(basic_streambuf<
     Allocator> const& streambuf, std::size_t max_size)
 {
-    auto const avail = streambuf.prepare_size();
+    auto const avail = streambuf.capacity() - streambuf.size();
     if(avail == 0)
         return std::min(max_size,
             std::max<std::size_t>(512, streambuf.alloc_size_));
@@ -866,7 +866,7 @@ template<class Alloc, class T>
 basic_streambuf<Alloc>&
 operator<<(basic_streambuf<Alloc>& streambuf, T const& t)
 {
-    detail::write_streambuf(streambuf, t);
+    detail::write_dynabuf(streambuf, t);
     return streambuf;
 }
 

include/beast/core/impl/dynabuf_readstream.ipp

@@ -5,8 +5,8 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifndef BEAST_IMPL_STREAMBUF_READSTREAM_IPP
-#define BEAST_IMPL_STREAMBUF_READSTREAM_IPP
+#ifndef BEAST_IMPL_DYNABUF_READSTREAM_HPP
+#define BEAST_IMPL_DYNABUF_READSTREAM_HPP
 
 #include <beast/core/bind_handler.hpp>
 #include <beast/core/handler_concepts.hpp>
@@ -16,24 +16,24 @@
 
 namespace beast {
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class MutableBufferSequence, class Handler>
-class streambuf_readstream<
-    Stream, Streambuf>::read_some_op
+class dynabuf_readstream<
+    Stream, DynamicBuffer>::read_some_op
 {
     using alloc_type =
         handler_alloc<char, Handler>;
 
     struct data
     {
-        streambuf_readstream& srs;
+        dynabuf_readstream& srs;
         MutableBufferSequence bs;
         Handler h;
         int state = 0;
 
         template<class DeducedHandler>
         data(DeducedHandler&& h_,
-            streambuf_readstream& srs_,
+            dynabuf_readstream& srs_,
                 MutableBufferSequence const& bs_)
             : srs(srs_)
             , bs(bs_)
@@ -50,7 +50,7 @@ public:
 
     template<class DeducedHandler, class... Args>
     read_some_op(DeducedHandler&& h,
-            streambuf_readstream& srs, Args&&... args)
+            dynabuf_readstream& srs, Args&&... args)
         : d_(std::allocate_shared<data>(alloc_type{h},
             std::forward<DeducedHandler>(h), srs,
                 std::forward<Args>(args)...))
@@ -94,10 +94,10 @@ public:
     }
 };
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class MutableBufferSequence, class Handler>
 void
-streambuf_readstream<Stream, Streambuf>::
+dynabuf_readstream<Stream, DynamicBuffer>::
 read_some_op<MutableBufferSequence, Handler>::operator()(
     error_code const& ec, std::size_t bytes_transferred)
 {
@@ -155,18 +155,18 @@ read_some_op<MutableBufferSequence, Handler>::operator()(
 
 //------------------------------------------------------------------------------
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class... Args>
-streambuf_readstream<Stream, Streambuf>::
-streambuf_readstream(Args&&... args)
+dynabuf_readstream<Stream, DynamicBuffer>::
+dynabuf_readstream(Args&&... args)
     : next_layer_(std::forward<Args>(args)...)
 {
 }
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class ConstBufferSequence, class WriteHandler>
 auto
-streambuf_readstream<Stream, Streambuf>::
+dynabuf_readstream<Stream, DynamicBuffer>::
 async_write_some(ConstBufferSequence const& buffers,
     WriteHandler&& handler) ->
         typename async_completion<
@@ -184,10 +184,10 @@ async_write_some(ConstBufferSequence const& buffers,
         std::forward<WriteHandler>(handler));
 }
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class MutableBufferSequence>
 std::size_t
-streambuf_readstream<Stream, Streambuf>::
+dynabuf_readstream<Stream, DynamicBuffer>::
 read_some(
     MutableBufferSequence const& buffers)
 {
@@ -203,10 +203,10 @@ read_some(
     return n;
 }
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class MutableBufferSequence>
 std::size_t
-streambuf_readstream<Stream, Streambuf>::
+dynabuf_readstream<Stream, DynamicBuffer>::
 read_some(MutableBufferSequence const& buffers,
     error_code& ec)
 {
@@ -232,10 +232,10 @@ read_some(MutableBufferSequence const& buffers,
     return bytes_transferred;
 }
 
-template<class Stream, class Streambuf>
+template<class Stream, class DynamicBuffer>
 template<class MutableBufferSequence, class ReadHandler>
 auto
-streambuf_readstream<Stream, Streambuf>::
+dynabuf_readstream<Stream, DynamicBuffer>::
 async_read_some(
     MutableBufferSequence const& buffers,
         ReadHandler&& handler) ->