Tidy up tests, build scripts, and documentation:

* Concepts split up into individual files
* Function definitions moved to .ipp files
* Add more tests to fill gaps in coverage
* Fix documentation Xsl

include/beast/impl/basic_streambuf.ipp

@@ -8,6 +8,7 @@
 #ifndef BEAST_IMPL_BASIC_STREAMBUF_IPP
 #define BEAST_IMPL_BASIC_STREAMBUF_IPP
 
+#include <beast/detail/write_streambuf.hpp>
 #include <algorithm>
 #include <cassert>
 #include <exception>
@@ -849,22 +850,6 @@ basic_streambuf<Allocator>::debug_check() const
 #endif
 }
 
-template<class Alloc, class T>
-basic_streambuf<Alloc>&
-operator<<(basic_streambuf<Alloc>& streambuf, T const& t)
-{
-    using boost::asio::buffer;
-    using boost::asio::buffer_copy;
-    std::stringstream ss;
-    ss << t;
-    auto const& s = ss.str();
-    streambuf.commit(buffer_copy(
-        streambuf.prepare(s.size()), buffer(s)));
-    return streambuf;
-}
-
-//------------------------------------------------------------------------------
-
 template<class Allocator>
 std::size_t
 read_size_helper(basic_streambuf<
@@ -874,17 +859,12 @@ read_size_helper(basic_streambuf<
         std::max<std::size_t>(512, streambuf.prepare_size()));
 }
 
-template<class Allocator>
-std::string
-to_string(basic_streambuf<Allocator> const& streambuf)
+template<class Alloc, class T>
+basic_streambuf<Alloc>&
+operator<<(basic_streambuf<Alloc>& streambuf, T const& t)
 {
-    using boost::asio::buffer;
-    using boost::asio::buffer_copy;
-    std::string s;
-    s.resize(streambuf.size());
-    buffer_copy(
-        buffer(&s[0], s.size()), streambuf.data());
-    return s;
+    detail::write_streambuf(streambuf, t);
+    return streambuf;
 }
 
 } // beast

include/beast/impl/buffers_adapter.ipp

@@ -17,8 +17,9 @@
 
 namespace beast {
 
-template<class Buffers>
-class buffers_adapter<Buffers>::const_buffers_type
+template<class MutableBufferSequence>
+class buffers_adapter<MutableBufferSequence>::
+    const_buffers_type
 {
     buffers_adapter const* ba_;
 
@@ -48,8 +49,9 @@ private:
     }
 };
 
-template<class Buffers>
-class buffers_adapter<Buffers>::const_buffers_type::const_iterator
+template<class MutableBufferSequence>
+class buffers_adapter<MutableBufferSequence>::
+    const_buffers_type::const_iterator
 {
     iter_type it_;
     buffers_adapter const* ba_ = nullptr;
@@ -136,19 +138,19 @@ private:
     }
 };
 
-template<class Buffers>
+template<class MutableBufferSequence>
 inline
 auto
-buffers_adapter<Buffers>::const_buffers_type::begin() const ->
+buffers_adapter<MutableBufferSequence>::const_buffers_type::begin() const ->
     const_iterator
 {
     return const_iterator{*ba_, ba_->begin_};
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 inline
 auto
-buffers_adapter<Buffers>::const_buffers_type::end() const ->
+buffers_adapter<MutableBufferSequence>::const_buffers_type::end() const ->
     const_iterator
 {
     return const_iterator{*ba_, ba_->out_ ==
@@ -157,8 +159,9 @@ buffers_adapter<Buffers>::const_buffers_type::end() const ->
 
 //------------------------------------------------------------------------------
 
-template<class Buffers>
-class buffers_adapter<Buffers>::mutable_buffers_type
+template<class MutableBufferSequence>
+class buffers_adapter<MutableBufferSequence>::
+mutable_buffers_type
 {
     buffers_adapter const* ba_;
 
@@ -189,8 +192,9 @@ private:
     }
 };
 
-template<class Buffers>
-class buffers_adapter<Buffers>::mutable_buffers_type::const_iterator
+template<class MutableBufferSequence>
+class buffers_adapter<MutableBufferSequence>::
+mutable_buffers_type::const_iterator
 {
     iter_type it_;
     buffers_adapter const* ba_ = nullptr;
@@ -277,19 +281,19 @@ private:
     }
 };
 
-template<class Buffers>
+template<class MutableBufferSequence>
 inline
 auto
-buffers_adapter<Buffers>::mutable_buffers_type::begin() const ->
+buffers_adapter<MutableBufferSequence>::mutable_buffers_type::begin() const ->
     const_iterator
 {
     return const_iterator{*ba_, ba_->out_};
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 inline
 auto
-buffers_adapter<Buffers>::mutable_buffers_type::end() const ->
+buffers_adapter<MutableBufferSequence>::mutable_buffers_type::end() const ->
     const_iterator
 {
     return const_iterator{*ba_, ba_->end_};
@@ -297,8 +301,8 @@ buffers_adapter<Buffers>::mutable_buffers_type::end() const ->
 
 //------------------------------------------------------------------------------
 
-template<class Buffers>
-buffers_adapter<Buffers>::buffers_adapter(
+template<class MutableBufferSequence>
+buffers_adapter<MutableBufferSequence>::buffers_adapter(
         buffers_adapter&& other)
     : buffers_adapter(std::move(other),
         std::distance<iter_type>(other.bs_.begin(), other.begin_),
@@ -307,8 +311,8 @@ buffers_adapter<Buffers>::buffers_adapter(
 {
 }
 
-template<class Buffers>
-buffers_adapter<Buffers>::buffers_adapter(
+template<class MutableBufferSequence>
+buffers_adapter<MutableBufferSequence>::buffers_adapter(
         buffers_adapter const& other)
     : buffers_adapter(other,
         std::distance<iter_type>(other.bs_.begin(), other.begin_),
@@ -317,9 +321,9 @@ buffers_adapter<Buffers>::buffers_adapter(
 {
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 auto
-buffers_adapter<Buffers>::operator=(
+buffers_adapter<MutableBufferSequence>::operator=(
     buffers_adapter&& other) -> buffers_adapter&
 {
     auto const nbegin = std::distance<iter_type>(
@@ -340,9 +344,9 @@ buffers_adapter<Buffers>::operator=(
     return *this;
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 auto
-buffers_adapter<Buffers>::operator=(
+buffers_adapter<MutableBufferSequence>::operator=(
     buffers_adapter const& other) -> buffers_adapter&
 {
     auto const nbegin = std::distance<iter_type>(
@@ -363,9 +367,9 @@ buffers_adapter<Buffers>::operator=(
     return *this;
 }
 
-template<class Buffers>
-buffers_adapter<Buffers>::buffers_adapter(
-    Buffers const& bs)
+template<class MutableBufferSequence>
+buffers_adapter<MutableBufferSequence>::buffers_adapter(
+    MutableBufferSequence const& bs)
     : bs_(bs)
     , begin_(bs_.begin())
     , out_(bs_.begin())
@@ -374,14 +378,12 @@ buffers_adapter<Buffers>::buffers_adapter(
 {
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 auto
-buffers_adapter<Buffers>::prepare(std::size_t n) ->
+buffers_adapter<MutableBufferSequence>::prepare(std::size_t n) ->
     mutable_buffers_type
 {
     using boost::asio::buffer_size;
-    static_assert(is_mutable,
-        "Operation not valid for ConstBufferSequence");
     end_ = out_;
     if(end_ != bs_.end())
     {
@@ -416,13 +418,11 @@ buffers_adapter<Buffers>::prepare(std::size_t n) ->
     return mutable_buffers_type{*this};
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 void
-buffers_adapter<Buffers>::commit(std::size_t n)
+buffers_adapter<MutableBufferSequence>::commit(std::size_t n)
 {
     using boost::asio::buffer_size;
-    static_assert(is_mutable,
-        "Operation not valid for ConstBufferSequence");
     if(out_ == end_)
         return;
     auto const last = std::prev(end_);
@@ -456,18 +456,18 @@ buffers_adapter<Buffers>::commit(std::size_t n)
     }
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 inline
 auto
-buffers_adapter<Buffers>::data() const ->
+buffers_adapter<MutableBufferSequence>::data() const ->
     const_buffers_type
 {
     return const_buffers_type{*this};
 }
 
-template<class Buffers>
+template<class MutableBufferSequence>
 void
-buffers_adapter<Buffers>::consume(std::size_t n)
+buffers_adapter<MutableBufferSequence>::consume(std::size_t n)
 {
     for(;;)
     {

include/beast/impl/consuming_buffers.ipp

@@ -8,7 +8,7 @@
 #ifndef BEAST_IMPL_CONSUMING_BUFFERS_IPP
 #define BEAST_IMPL_CONSUMING_BUFFERS_IPP
 
-#include <beast/type_check.hpp>
+#include <beast/buffer_concepts.hpp>
 #include <boost/asio/buffer.hpp>
 #include <algorithm>
 #include <cstdint>
@@ -18,13 +18,13 @@
 
 namespace beast {
 
-template<class Buffers, class ValueType>
-class consuming_buffers<Buffers, ValueType>::const_iterator
+template<class BufferSequence, class ValueType>
+class consuming_buffers<BufferSequence, ValueType>::const_iterator
 {
-    friend class consuming_buffers<Buffers, ValueType>;
+    friend class consuming_buffers<BufferSequence, ValueType>;
 
     using iter_type =
-        typename Buffers::const_iterator;
+        typename BufferSequence::const_iterator;
 
     iter_type it_;
     consuming_buffers const* b_ = nullptr;
@@ -105,8 +105,8 @@ private:
     }
 };
 
-template<class Buffers, class ValueType>
-consuming_buffers<Buffers, ValueType>::
+template<class BufferSequence, class ValueType>
+consuming_buffers<BufferSequence, ValueType>::
 consuming_buffers(consuming_buffers&& other)
     : consuming_buffers(std::move(other),
         std::distance<iter_type>(
@@ -114,8 +114,8 @@ consuming_buffers(consuming_buffers&& other)
 {
 }
 
-template<class Buffers, class ValueType>
-consuming_buffers<Buffers, ValueType>::
+template<class BufferSequence, class ValueType>
+consuming_buffers<BufferSequence, ValueType>::
 consuming_buffers(consuming_buffers const& other)
     : consuming_buffers(other,
         std::distance<iter_type>(
@@ -123,9 +123,9 @@ consuming_buffers(consuming_buffers const& other)
 {
 }
 
-template<class Buffers, class ValueType>
+template<class BufferSequence, class ValueType>
 auto
-consuming_buffers<Buffers, ValueType>::
+consuming_buffers<BufferSequence, ValueType>::
 operator=(consuming_buffers&& other) ->
     consuming_buffers&
 {
@@ -137,9 +137,9 @@ operator=(consuming_buffers&& other) ->
     return *this;
 }
 
-template<class Buffers, class ValueType>
+template<class BufferSequence, class ValueType>
 auto
-consuming_buffers<Buffers, ValueType>::
+consuming_buffers<BufferSequence, ValueType>::
 operator=(consuming_buffers const& other) ->
     consuming_buffers&
 {
@@ -151,35 +151,35 @@ operator=(consuming_buffers const& other) ->
     return *this;
 }
 
-template<class Buffers, class ValueType>
-consuming_buffers<Buffers, ValueType>::
-consuming_buffers(Buffers const& bs)
+template<class BufferSequence, class ValueType>
+consuming_buffers<BufferSequence, ValueType>::
+consuming_buffers(BufferSequence const& bs)
     : bs_(bs)
     , begin_(bs_.begin())
 {
-    static_assert(is_BufferSequence<Buffers, ValueType>::value,
+    static_assert(is_BufferSequence<BufferSequence, ValueType>::value,
         "BufferSequence requirements not met");
 }
 
-template<class Buffers, class ValueType>
+template<class BufferSequence, class ValueType>
 auto
-consuming_buffers<Buffers, ValueType>::begin() const ->
+consuming_buffers<BufferSequence, ValueType>::begin() const ->
     const_iterator
 {
     return const_iterator{*this, begin_};
 }
 
-template<class Buffers, class ValueType>
+template<class BufferSequence, class ValueType>
 auto
-consuming_buffers<Buffers, ValueType>::end() const ->
+consuming_buffers<BufferSequence, ValueType>::end() const ->
     const_iterator
 {
     return const_iterator{*this, bs_.end()};
 }
 
-template<class Buffers, class ValueType>
+template<class BufferSequence, class ValueType>
 void
-consuming_buffers<Buffers, ValueType>::consume(std::size_t n)
+consuming_buffers<BufferSequence, ValueType>::consume(std::size_t n)
 {
     using boost::asio::buffer_size;
     for(;n > 0 && begin_ != bs_.end(); ++begin_)
@@ -196,11 +196,11 @@ consuming_buffers<Buffers, ValueType>::consume(std::size_t n)
     }
 }
 
-template<class Buffers>
-consuming_buffers<Buffers, typename Buffers::value_type>
-consumed_buffers(Buffers const& bs, std::size_t n)
+template<class BufferSequence>
+consuming_buffers<BufferSequence, typename BufferSequence::value_type>
+consumed_buffers(BufferSequence const& bs, std::size_t n)
 {
-    consuming_buffers<Buffers> cb(bs);
+    consuming_buffers<BufferSequence> cb(bs);
     cb.consume(n);
     return cb;
 }

include/beast/impl/streambuf_readstream.ipp

@@ -9,7 +9,10 @@
 #define BEAST_IMPL_STREAMBUF_READSTREAM_IPP
 
 #include <beast/bind_handler.hpp>
+#include <beast/handler_concepts.hpp>
 #include <beast/handler_alloc.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_error.hpp>
 
 namespace beast {
 
@@ -157,8 +160,6 @@ streambuf_readstream<Stream, Streambuf>::
 streambuf_readstream(Args&&... args)
     : next_layer_(std::forward<Args>(args)...)
 {
-    static_assert(is_Streambuf<Streambuf>::value,
-        "Streambuf requirements not met");
 }
 
 template<class Stream, class Streambuf>
@@ -175,7 +176,7 @@ async_write_some(ConstBufferSequence const& buffers,
     static_assert(is_ConstBufferSequence<
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
-    static_assert(is_Handler<WriteHandler,
+    static_assert(is_CompletionHandler<WriteHandler,
         void(error_code, std::size_t)>::value,
             "WriteHandler requirements not met");
     return next_layer_.async_write_some(buffers,