serializer has simpler buffer logic

include/boost/http_proto/impl/serializer.hpp

@@ -18,100 +18,96 @@
 namespace boost {
 namespace http_proto {
 
-class serializer::const_buf_gen_base
+class serializer::cbs_gen
 {
 public:
-    // Return the next non-empty buffer,
-    // or an empty buffer if none remain.
+    struct stats_t
+    {
+        std::size_t size = 0;
+        std::size_t count = 0;
+    };
+
+    // Return the next non-empty buffer or an
+    // empty buffer if none remain.
     virtual
     buffers::const_buffer
     next() = 0;
 
-    // Size of remaining buffers
-    virtual
-    std::size_t
-    size() const = 0;
-
-    // Count of remaining non-empty buffers
+    // Return the total size and count of
+    // remaining non-empty buffers.
     virtual
-    std::size_t
-    count() const = 0;
+    stats_t
+    stats() const = 0;
 
-    // Return true when there is no buffer or
-    // the remaining buffers are empty
+    // Return true if there are no remaining
+    // non-empty buffers.
     virtual
     bool
     is_empty() const = 0;
 };
 
 template<class ConstBufferSequence>
-class serializer::const_buf_gen
-    : public const_buf_gen_base
+class serializer::cbs_gen_impl
+    : public cbs_gen
 {
     using it_t = decltype(buffers::begin(
         std::declval<ConstBufferSequence>()));
 
     ConstBufferSequence cbs_;
-    it_t current_;
+    it_t curr_;
 
 public:
     using const_buffer =
         buffers::const_buffer;
 
     explicit
-    const_buf_gen(ConstBufferSequence cbs)
+    cbs_gen_impl(ConstBufferSequence cbs)
         : cbs_(std::move(cbs))
-        , current_(buffers::begin(cbs_))
+        , curr_(buffers::begin(cbs_))
     {
     }
 
     const_buffer
     next() override
     {
-        while(current_ != buffers::end(cbs_))
+        while(curr_ != buffers::end(cbs_))
         {
-            const_buffer buf = *current_++;
+            // triggers conversion operator
+            const_buffer buf = *curr_++;
             if(buf.size() != 0)
                 return buf;
         }
         return {};
     }
 
-    std::size_t
-    size() const override
-    {
-        return std::accumulate(
-            current_,
-            buffers::end(cbs_),
-            std::size_t{},
-            [](std::size_t sum, const_buffer cb)
-            {
-                return sum + cb.size();
-            });
-    }
-
-    std::size_t
-    count() const override
+    stats_t
+    stats() const override
     {
-        return std::count_if(
-            current_,
-            buffers::end(cbs_),
-            [](const_buffer cb)
+        stats_t r;
+        for(auto it = curr_; it != buffers::end(cbs_); ++it)
+        {
+            // triggers conversion operator
+            const_buffer buf = *it;
+            if(buf.size() != 0)
             {
-                return cb.size() != 0;
-            });
+                r.size  += buf.size();
+                r.count += 1;
+            }
+        }
+        return r;
     }
 
     bool
     is_empty() const override
     {
-        return std::all_of(
-            current_,
-            buffers::end(cbs_),
-            [](const_buffer cb)
-            {
-                return cb.size() == 0;
-            });
+        for(auto it = curr_; it != buffers::end(cbs_); ++it)
+        {
+            // triggers conversion operator
+            const_buffer buf = *it;
+            if(buf.size() != 0)
+                return false;
+        }
+        return true;
     }
 };
 
@@ -131,8 +127,8 @@ start(
         "ConstBufferSequence type requirements not met");
 
     start_init(m);
-    buf_gen_ = std::addressof(
-        ws_.emplace<const_buf_gen<typename
+    cbs_gen_ = std::addressof(
+        ws_.emplace<cbs_gen_impl<typename
         std::decay<ConstBufferSequence>::type>>(
                 std::forward<ConstBufferSequence>(cbs)));
     start_buffers(m);

include/boost/http_proto/serializer.hpp

@@ -553,9 +553,9 @@ class serializer
     }
 
 private:
-    class const_buf_gen_base;
+    class cbs_gen;
     template<class>
-    class const_buf_gen;
+    class cbs_gen_impl;
 
     detail::array_of_const_buffers
     make_array(std::size_t n);
@@ -648,7 +648,7 @@ class serializer
     detail::workspace ws_;
 
     detail::filter* filter_ = nullptr;
-    const_buf_gen_base* buf_gen_ = nullptr;
+    cbs_gen* cbs_gen_ = nullptr;
     source* source_ = nullptr;
 
     buffers::circular_buffer out_;

src/detail/impl/array_of_const_buffers.cpp → src/detail/array_of_const_buffers.cpp

@@ -20,11 +20,11 @@ namespace detail {
 array_of_const_buffers::
 array_of_const_buffers(
     value_type* p,
-    std::uint16_t n) noexcept
+    std::uint16_t capacity) noexcept
     : base_(p)
-    , cap_(n)
+    , cap_(capacity)
     , pos_(0)
-    , size_(n)
+    , size_(0)
 {
 }