Use a struct instead of pair in flat_stream

No need to instantiate a pair and a custom struct has better member
names.

Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>

CHANGELOG.md

@@ -2,6 +2,7 @@ Version 197:
 
 * Improvements to echo-op example
 * Crawler example clears the response before each read
+* Use a struct instead of a pair in flat_stream (experimental)
 
 API Changes:
 

include/boost/beast/_experimental/core/detail/flat_stream.hpp

@@ -12,7 +12,6 @@
 
 #include <boost/asio/buffer.hpp>
 #include <cstdlib>
-#include <iterator>
 
 namespace boost {
 namespace beast {
@@ -25,19 +24,25 @@ public:
     // 16KB is the upper limit on reasonably sized HTTP messages.
     static std::size_t constexpr coalesce_limit = 16 * 1024;
 
+    struct coalesce_result
+    {
+        std::size_t size;
+        bool needs_coalescing;
+    };
+
     // calculates the coalesce settings for a buffer sequence
     template<class BufferSequence>
     static
-    std::pair<std::size_t, bool>
+    coalesce_result
     coalesce(BufferSequence const& buffers, std::size_t limit)
     {
-        std::pair<std::size_t, bool> result{0, false};
+        coalesce_result result{0, false};
         auto first = net::buffer_sequence_begin(buffers);
         auto last = net::buffer_sequence_end(buffers);
         if(first != last)
         {
-            result.first = net::buffer_size(*first);
+            result.size = net::buffer_size(*first);
-            if(result.first < limit)
+            if(result.size < limit)
             {
                 auto it = first;
                 auto prev = first;
@@ -45,12 +50,12 @@ public:
                 {
                     auto const n =
                         net::buffer_size(*it);
-                    if(result.first + n > limit)
+                    if(result.size + n > limit)
                         break;
-                    result.first += n;
+                    result.size += n;
                     prev = it;
                 }
-                result.second = prev != first;
+                result.needs_coalescing = prev != first;
             }
         }
         return result;

include/boost/beast/_experimental/core/impl/flat_stream.ipp

@@ -27,7 +27,7 @@ template<class ConstBufferSequence, class Handler>
 class flat_stream<NextLayer>::write_op
     : public net::coroutine
 {
-    using alloc_type = typename 
+    using alloc_type = typename
 #if defined(BOOST_NO_CXX11_ALLOCATOR)
         net::associated_allocator_t<Handler>::template
             rebind<char>::other;
@@ -128,15 +128,15 @@ operator()(
         BOOST_ASIO_CORO_YIELD
         {
             auto const result = coalesce(b_,  coalesce_limit);
-            if(result.second)
+            if(result.needs_coalescing)
             {
-                p_.get_deleter().size = result.first;
+                p_.get_deleter().size = result.size;
                 p_.reset(p_.get_deleter().alloc.allocate(
                     p_.get_deleter().size));
                 net::buffer_copy(
                     net::buffer(
                         p_.get(), p_.get_deleter().size),
-                    b_, result.first);
+                    b_, result.size);
                 s_.stream_.async_write_some(
                     net::buffer(
                         p_.get(), p_.get_deleter().size),
@@ -145,7 +145,7 @@ operator()(
             else
             {
                 s_.stream_.async_write_some(
-                    boost::beast::buffers_prefix(result.first, b_),
+                    boost::beast::buffers_prefix(result.size, b_),
                         std::move(*this));
             }
         }
@@ -223,15 +223,15 @@ write_some(ConstBufferSequence const& buffers)
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     auto const result = coalesce(buffers, coalesce_limit);
-    if(result.second)
+    if(result.needs_coalescing)
     {
-        std::unique_ptr<char[]> p{new char[result.first]};
+        std::unique_ptr<char[]> p{new char[result.size]};
-        auto const b = net::buffer(p.get(), result.first);
+        auto const b = net::buffer(p.get(), result.size);
         net::buffer_copy(b, buffers);
         return stream_.write_some(b);
     }
     return stream_.write_some(
-        boost::beast::buffers_prefix(result.first, buffers));
+        boost::beast::buffers_prefix(result.size, buffers));
 }
 
 template<class NextLayer>
@@ -246,15 +246,15 @@ write_some(ConstBufferSequence const& buffers, error_code& ec)
         ConstBufferSequence>::value,
             "ConstBufferSequence requirements not met");
     auto const result = coalesce(buffers, coalesce_limit);
-    if(result.second)
+    if(result.needs_coalescing)
     {
-        std::unique_ptr<char[]> p{new char[result.first]};
+        std::unique_ptr<char[]> p{new char[result.size]};
-        auto const b = net::buffer(p.get(), result.first);
+        auto const b = net::buffer(p.get(), result.size);
         net::buffer_copy(b, buffers);
         return stream_.write_some(b, ec);
     }
     return stream_.write_some(
-        boost::beast::buffers_prefix(result.first, buffers), ec);
+        boost::beast::buffers_prefix(result.size, buffers), ec);
 }
 
 template<class NextLayer>

test/beast/experimental/flat_stream.cpp

@@ -40,8 +40,8 @@ public:
                     v.emplace_back("", n);
                 auto const result =
                     boost::beast::detail::flat_stream_base::coalesce(v, limit);
-                BEAST_EXPECT(result.first == count);
+                BEAST_EXPECT(result.size == count);
-                BEAST_EXPECT(result.second == copy);
+                BEAST_EXPECT(result.needs_coalescing == copy);
                 return result;
             };
         check({},           1,    0, false);