New buffers() replaces to_string() (API Change):

A new function, buffers(), returns an implementation defined object
which wraps a ConstBufferSequence and supports formatting to a
std::ostream.

The function to_string is removed, as the new implementation allows
conversion to string using boost::lexical_cast on the return value
of the call to buffers(). Streaming to an output stream is more
efficient: no dynamic allocations are performed.

Example:

    streambuf sb;
    std::cout << buffers(sb.data()) << std::endl;

include/beast/core.hpp

@@ -17,19 +17,18 @@
 #include <beast/core/buffers_adapter.hpp>
 #include <beast/core/consuming_buffers.hpp>
 #include <beast/core/dynabuf_readstream.hpp>
-#include <beast/core/ostream.hpp>
 #include <beast/core/error.hpp>
 #include <beast/core/flat_streambuf.hpp>
 #include <beast/core/handler_alloc.hpp>
 #include <beast/core/handler_concepts.hpp>
 #include <beast/core/handler_helpers.hpp>
 #include <beast/core/handler_ptr.hpp>
+#include <beast/core/ostream.hpp>
 #include <beast/core/placeholders.hpp>
 #include <beast/core/prepare_buffers.hpp>
 #include <beast/core/static_streambuf.hpp>
 #include <beast/core/static_string.hpp>
 #include <beast/core/stream_concepts.hpp>
 #include <beast/core/streambuf.hpp>
-#include <beast/core/to_string.hpp>
 
 #endif

include/beast/core/detail/ostream.hpp

@@ -19,6 +19,40 @@
 namespace beast {
 namespace detail {
 
+template<class Buffers>
+class buffers_helper
+{
+    Buffers b_;
+
+public:
+    explicit
+    buffers_helper(Buffers const& b)
+        : b_(b)
+    {
+    }
+
+    template<class B>
+    friend
+    std::ostream&
+    operator<<(std::ostream& os,
+        buffers_helper<B> const& v);
+};
+
+template<class Buffers>
+std::ostream&
+operator<<(std::ostream& os,
+    buffers_helper<Buffers> const& v)
+{
+    using boost::asio::buffer_cast;
+    using boost::asio::buffer_size;
+    for(auto const& b : v.b_)
+        os.write(buffer_cast<char const*>(b),
+            buffer_size(b));
+    return os;
+}
+
+//------------------------------------------------------------------------------
+
 template<
     class DynamicBuffer,
     class CharT,

include/beast/core/ostream.hpp

@@ -17,6 +17,40 @@
 
 namespace beast {
 
+/** Return an object representing a @b ConstBufferSequence.
+
+    This function wraps a reference to a buffer sequence and permits
+    the following operation:
+
+    @li `operator<<` to `std::ostream`. No character translation is
+        performed; unprintable and null characters will be transferred
+        as-is to the output stream.
+
+    @par Example
+    @code
+        streambuf sb;
+        ...
+        std::cout << buffers(sb.data()) << std::endl;
+    @endcode
+
+    @param b An object meeting the requirements of @b ConstBufferSequence
+    to be streamed. The implementation will make a copy of this object.
+*/
+template<class ConstBufferSequence>
+#if BEAST_DOXYGEN
+implementation_defined
+#else
+detail::buffers_helper<ConstBufferSequence>
+#endif
+buffers(ConstBufferSequence const& b)
+{
+    static_assert(is_ConstBufferSequence<
+        ConstBufferSequence>::value,
+            "ConstBufferSequence not met");
+    return detail::buffers_helper<
+        ConstBufferSequence>{b};
+}
+
 /** Return an output stream that formats values into a @b DynamicBuffer.
 
     This function wraps the caller provided @b DynamicBuffer into

include/beast/core/to_string.hpp

@@ -1,53 +0,0 @@
-//
-// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BEAST_TO_STRING_HPP
-#define BEAST_TO_STRING_HPP
-
-#include <beast/config.hpp>
-#include <beast/core/buffer_concepts.hpp>
-#include <boost/asio/buffer.hpp>
-#include <string>
-
-namespace beast {
-
-/** Convert a @b `ConstBufferSequence` to a `std::string`.
-
-    This function will convert the octets in a buffer sequence to a string.
-    All octets will be inserted into the resulting string, including null
-    or unprintable characters.
-
-    @param buffers The buffer sequence to convert.
-
-    @return A string representing the contents of the input area.
-
-    @note This function participates in overload resolution only if
-    the buffers parameter meets the requirements of @b `ConstBufferSequence`.
-*/
-template<class ConstBufferSequence>
-#if BEAST_DOXYGEN
-std::string
-#else
-typename std::enable_if<
-    is_ConstBufferSequence<ConstBufferSequence>::value,
-        std::string>::type
-#endif
-to_string(ConstBufferSequence const& buffers)
-{
-    using boost::asio::buffer_cast;
-    using boost::asio::buffer_size;
-    std::string s;
-    s.reserve(buffer_size(buffers));
-    for(auto const& buffer : buffers)
-        s.append(buffer_cast<char const*>(buffer),
-            buffer_size(buffer));
-    return s;
-}
-
-} // beast
-
-#endif