EIC code displayed by LXR master/​include/​boost/​beast/​core/​impl/​multi_buffer.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:29:27

 //
 // Copyright (c) 2016-2019 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)
 //
 // Official repository: https://github.com/boostorg/beast
 //
 
 #ifndef BOOST_BEAST_IMPL_MULTI_BUFFER_HPP
 #define BOOST_BEAST_IMPL_MULTI_BUFFER_HPP
 
 #include <boost/beast/core/buffer_traits.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/exchange.hpp>
 #include <boost/assert.hpp>
 #include <boost/throw_exception.hpp>
 #include <algorithm>
 #include <exception>
 #include <iterator>
 #include <sstream>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 namespace boost {
 namespace beast {
 
 /*  These diagrams illustrate the layout and state variables.
 
 1   Input and output contained entirely in one element:
 
     0                           out_
     |<------+-----------+--------------------------------+----->|
           in_pos_    out_pos_                         out_end_
 
 
 2   Output contained in first and second elements:
 
                  out_
     |<------+-----------+------>|   |<-------------------+----->|
           in_pos_    out_pos_                         out_end_
 
 
 3   Output contained in the second element:
 
                                                   out_
     |<------+------------------>|   |<----+--------------+----->|
           in_pos_                      out_pos_       out_end_
 
 
 4   Output contained in second and third elements:
 
                                  out_
     |<------+------->|   |<-------+------>|   |<---------+----->|
           in_pos_               out_pos_              out_end_
 
 
 5   Input sequence is empty:
 
                  out_
     |<------+------------------>|   |<-------------------+----->|
          out_pos_                                     out_end_
           in_pos_
 
 6   Output sequence is empty:
 
                                                     out_
     |<------+------------------>|   |<------+------------------>|
           in_pos_                        out_pos_
                                          out_end_
 
 
 7   The end of output can point to the end of an element.
     But out_pos_ should never point to the end:
 
                                                     out_
     |<------+------------------>|   |<------+------------------>|
           in_pos_                        out_pos_            out_end_
 
 
 8   When the input sequence entirely fills the last element and
     the output sequence is empty, out_ will point to the end of
     the list of buffers, and out_pos_ and out_end_ will be 0:
 
 
     |<------+------------------>|   out_     == list_.end()
           in_pos_                   out_pos_ == 0
                                     out_end_ == 0
 */
 
 //------------------------------------------------------------------------------
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 # pragma warning (push)
 # pragma warning (disable: 4521) // multiple copy constructors specified
 # pragma warning (disable: 4522) // multiple assignment operators specified
 #endif
 
 template<class Allocator>
 template<bool isMutable>
 class basic_multi_buffer<Allocator>::subrange
 {
     basic_multi_buffer const* b_;
     const_iter begin_;
     const_iter end_;
     size_type begin_pos_;   // offset in begin_
     size_type last_pos_;    // offset in std::prev(end_)
 
     friend class basic_multi_buffer;
 
     subrange(
         basic_multi_buffer const& b,
         size_type pos,
         size_type n) noexcept
         : b_(&b)
     {
         auto const set_empty = [&]
         {
             begin_ = b_->list_.end();
             end_ = b_->list_.end();
             begin_pos_ = 0;
             last_pos_ = 0;
         };
 
         // VFALCO Handle this trivial case of
         // pos larger than total size, otherwise
         // the addition to pos can overflow.
         //if(pos >= b_->in_size_)
         // skip unused prefix
         pos = pos + b_->in_pos_;
 
         // iterate the buffers
         auto it = b_->list_.begin();
 
         // is the list empty?
         if(it == b_->list_.end())
         {
             set_empty();
             return;
         }
         
         // is the requested size zero?
         if(n == 0)
         {
             set_empty();
             return;
         }
 
 
         // get last buffer and its size
         auto const last =
             std::prev(b_->list_.end());
         auto const last_end =
             [&]
             {
                 if(b_->out_end_ == 0)
                     return last->size();
                 return b_->out_end_;
             }();
 
         // only one buffer in list?
         if(it == last)
         {
             if(pos >= last_end)
             {
                 set_empty();
                 return;
             }
 
             begin_ = it;
             begin_pos_ = pos;
             end_ = std::next(it);
             if(n > last_end - pos)
                 last_pos_ = last_end;
             else
                 last_pos_ = pos + n;
             return;
         }
 
         for(;;)
         {
             // is pos in this buffer?
             if(pos < it->size())
             {
                 begin_ = it;
                 begin_pos_ = pos;
 
                 // does this buffer satisfy n?
                 auto const avail =
                     it->size() - pos;
                 if(n <= avail)
                 {
                     end_ = ++it;
                     last_pos_ = pos + n;
                     return;
                 }
 
                 n -= avail;
                 ++it;
                 break;
             }
 
             pos -= it->size();
             ++it;
 
             // did we reach the last buffer?
             if(it == last)
             {
                 // is pos past the end?
                 if(pos >= last_end)
                 {
                     set_empty();
                     return;
                 }
 
                 // satisfy the request
                 begin_ = it;
                 begin_pos_ = pos;
                 end_ = std::next(it);
                 if(n < last_end - pos)
                     last_pos_ = pos + n;
                 else
                     last_pos_ = last_end;
                 return;
             }
         }
 
         // find pos+n
         for(;;)
         {
             if(it == last)
             {
                 end_ = ++it;
                 if(n >= last_end)
                     last_pos_ = last_end;
                 else
                     last_pos_ = n;
                 return;
             }
             if(n <= it->size())
             {
                 end_ = ++it;
                 last_pos_ = n;
                 return;
             }
             
             n -= it->size();
             ++it;
         }
     }
 
 public:
     using value_type = typename
         std::conditional<
             isMutable,
             net::mutable_buffer,
             net::const_buffer>::type;
 
     class const_iterator;
 
     subrange() = delete;
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
     subrange(subrange const& other)
         : b_(other.b_)
         , begin_(other.begin_)
         , end_(other.end_)
         , begin_pos_(other.begin_pos_)
         , last_pos_(other.last_pos_)
     {
     }
 
     subrange& operator=(subrange const& other)
     {
         b_ = other.b_;
         begin_ = other.begin_;
         end_ = other.end_;
         begin_pos_ = other.begin_pos_;
         last_pos_ = other.last_pos_;
         return *this;
     }
 #else
     subrange(subrange const&) = default;
     subrange& operator=(subrange const&) = default;
 #endif
 
     template<
         bool isMutable_ = isMutable,
         class = typename std::enable_if<! isMutable_>::type>
     subrange(
         subrange<true> const& other) noexcept
         : b_(other.b_)
         , begin_(other.begin_)
         , end_(other.end_)
         , begin_pos_(other.begin_pos_)
         , last_pos_(other.last_pos_)
    {
     }
 
     template<
         bool isMutable_ = isMutable,
         class = typename std::enable_if<! isMutable_>::type>
     subrange& operator=(
         subrange<true> const& other) noexcept
     {
         b_ = other.b_;
         begin_ = other.begin_;
         end_ = other.end_;
         begin_pos_ = other.begin_pos_;
         last_pos_ = other.last_pos_;
         return *this;
     }
 
     const_iterator begin() const noexcept;
     const_iterator end() const noexcept;
 
     std::size_t
     buffer_bytes() const noexcept
     {
         return b_->size();
     }
 };
 
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 # pragma warning (pop)
 #endif
 
 //------------------------------------------------------------------------------
 
 template<class Allocator>
 template<bool isMutable>
 class
     basic_multi_buffer<Allocator>::
     subrange<isMutable>::
     const_iterator
 {
     friend class subrange;
 
     subrange const* sr_ = nullptr;
     typename list_type::const_iterator it_;
 
     const_iterator(
         subrange const& sr, typename
         list_type::const_iterator const& it) noexcept
         : sr_(&sr)
         , it_(it)
     {
     }
 
 public:
     using value_type =
         typename subrange::value_type;
     using pointer = value_type const*;
     using reference = value_type;
     using difference_type = std::ptrdiff_t;
     using iterator_category =
         std::bidirectional_iterator_tag;
 
     const_iterator() = default;
     const_iterator(
         const_iterator const& other) = default;
     const_iterator& operator=(
         const_iterator const& other) = default;
 
     bool
     operator==(
         const_iterator const& other) const noexcept
     {
         return sr_ == other.sr_ && it_ == other.it_;
     }
 
     bool
     operator!=(
         const_iterator const& other) const noexcept
     {
         return !(*this == other);
     }
 
     reference
     operator*() const noexcept
     {
         value_type result;
         BOOST_ASSERT(sr_->last_pos_ != 0);
         if(it_ == std::prev(sr_->end_))
             result = {
                 it_->data(), sr_->last_pos_ };
         else
             result = {
                 it_->data(), it_->size() };
         if(it_ == sr_->begin_)
             result += sr_->begin_pos_;
         return result;
     }
 
     pointer
     operator->() const = delete;
 
     const_iterator&
     operator++() noexcept
     {
         ++it_;
         return *this;
     }
 
     const_iterator
     operator++(int) noexcept
     {
         auto temp = *this;
         ++(*this);
         return temp;
     }
 
     const_iterator&
     operator--() noexcept
     {
         --it_;
         return *this;
     }
 
     const_iterator
     operator--(int) noexcept
     {
         auto temp = *this;
         --(*this);
         return temp;
     }
 };
 
 //------------------------------------------------------------------------------
 
 template<class Allocator>
 template<bool isMutable>
 auto
 basic_multi_buffer<Allocator>::
 subrange<isMutable>::
 begin() const noexcept ->
     const_iterator
 {
     return const_iterator(
         *this, begin_);
 }
 
 template<class Allocator>
 template<bool isMutable>
 auto
 basic_multi_buffer<Allocator>::
 subrange<isMutable>::
 end() const noexcept ->
     const_iterator
 {
     return const_iterator(
         *this, end_);
 }
 
 //------------------------------------------------------------------------------
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 ~basic_multi_buffer()
 {
     destroy(list_);
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer() noexcept(default_nothrow)
     : max_(alloc_traits::max_size(this->get()))
     , out_(list_.end())
 {
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     std::size_t limit) noexcept(default_nothrow)
     : max_(limit)
     , out_(list_.end())
 {
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     Allocator const& alloc) noexcept
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), alloc)
     , max_(alloc_traits::max_size(this->get()))
     , out_(list_.end())
 {
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     std::size_t limit,
     Allocator const& alloc) noexcept
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), alloc)
     , max_(limit)
     , out_(list_.end())
 {
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     basic_multi_buffer&& other) noexcept
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), std::move(other.get()))
     , max_(other.max_)
     , in_size_(boost::exchange(other.in_size_, 0))
     , in_pos_(boost::exchange(other.in_pos_, 0))
     , out_pos_(boost::exchange(other.out_pos_, 0))
     , out_end_(boost::exchange(other.out_end_, 0))
 {
     auto const at_end =
         other.out_ == other.list_.end();
     list_ = std::move(other.list_);
     out_ = at_end ? list_.end() : other.out_;
     other.out_ = other.list_.end();
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     basic_multi_buffer&& other,
     Allocator const& alloc)
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), alloc)
     , max_(other.max_)
 {
     if(this->get() != other.get())
     {
         out_ = list_.end();
         copy_from(other);
         return;
     }
 
     auto const at_end =
         other.out_ == other.list_.end();
     list_ = std::move(other.list_);
     out_ = at_end ? list_.end() : other.out_;
     in_size_ = other.in_size_;
     in_pos_ = other.in_pos_;
     out_pos_ = other.out_pos_;
     out_end_ = other.out_end_;
     other.in_size_ = 0;
     other.out_ = other.list_.end();
     other.in_pos_ = 0;
     other.out_pos_ = 0;
     other.out_end_ = 0;
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     basic_multi_buffer const& other)
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), alloc_traits::
             select_on_container_copy_construction(
                 other.get()))
     , max_(other.max_)
     , out_(list_.end())
 {
     copy_from(other);
 }
 
 template<class Allocator>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     basic_multi_buffer const& other,
     Allocator const& alloc)
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), alloc)
     , max_(other.max_)
     , out_(list_.end())
 {
     copy_from(other);
 }
 
 template<class Allocator>
 template<class OtherAlloc>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
         basic_multi_buffer<OtherAlloc> const& other)
     : out_(list_.end())
 {
     copy_from(other);
 }
 
 template<class Allocator>
 template<class OtherAlloc>
 basic_multi_buffer<Allocator>::
 basic_multi_buffer(
     basic_multi_buffer<OtherAlloc> const& other,
         allocator_type const& alloc)
     : boost::empty_value<Allocator>(
         boost::empty_init_t(), alloc)
     , max_(other.max_)
     , out_(list_.end())
 {
     copy_from(other);
 }
 
 template<class Allocator>
 auto
 basic_multi_buffer<Allocator>::
 operator=(basic_multi_buffer&& other) ->
     basic_multi_buffer&
 {
     if(this == &other)
         return *this;
     clear();
     max_ = other.max_;
     move_assign(other, pocma{});
     return *this;
 }
 
 template<class Allocator>
 auto
 basic_multi_buffer<Allocator>::
 operator=(basic_multi_buffer const& other) ->
 basic_multi_buffer&
 {
     if(this == &other)
         return *this;
     copy_assign(other, pocca{});
     return *this;
 }
 
 template<class Allocator>
 template<class OtherAlloc>
 auto
 basic_multi_buffer<Allocator>::
 operator=(
     basic_multi_buffer<OtherAlloc> const& other) ->
         basic_multi_buffer&
 {
     copy_from(other);
     return *this;
 }
 
 //------------------------------------------------------------------------------
 
 template<class Allocator>
 std::size_t
 basic_multi_buffer<Allocator>::
 capacity() const noexcept
 {
     auto pos = out_;
     if(pos == list_.end())
         return in_size_;
     auto n = pos->size() - out_pos_;
     while(++pos != list_.end())
         n += pos->size();
     return in_size_ + n;
 }
 
 template<class Allocator>
 auto
 basic_multi_buffer<Allocator>::
 data() const noexcept ->
     const_buffers_type
 {
     return const_buffers_type(
         *this, 0, in_size_);
 }
 
 template<class Allocator>
 auto
 basic_multi_buffer<Allocator>::
 data() noexcept ->
     mutable_buffers_type
 {
     return mutable_buffers_type(
         *this, 0, in_size_);
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 reserve(std::size_t n)
 {
     // VFALCO The amount needs to be adjusted for
     //        the sizeof(element) plus padding
     if(n > alloc_traits::max_size(this->get()))
         BOOST_THROW_EXCEPTION(std::length_error(
         "A basic_multi_buffer exceeded the allocator's maximum size"));
     std::size_t total = in_size_;
     if(n <= total)
         return;
     if(out_ != list_.end())
     {
         total += out_->size() - out_pos_;
         if(n <= total)
             return;
         for(auto it = out_;;)
         {
             if(++it == list_.end())
                 break;
             total += it->size();
             if(n <= total)
                 return;
         }
     }
     BOOST_ASSERT(n > total);
     (void)prepare(n - size());
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 shrink_to_fit()
 {
     // empty list
     if(list_.empty())
         return;
 
     // zero readable bytes
     if(in_size_ == 0)
     {
         destroy(list_);
         list_.clear();
         out_ = list_.end();
         in_size_ = 0;
         in_pos_ = 0;
         out_pos_ = 0;
         out_end_ = 0;
     #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
         debug_check();
     #endif
         return;
     }
 
     // one or more unused output buffers
     if(out_ != list_.end())
     {
         if(out_ != list_.iterator_to(list_.back()))
         {
             // unused list
             list_type extra;
             extra.splice(
                 extra.end(),
                 list_,
                 std::next(out_),
                 list_.end());
             destroy(extra);
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
         }
 
         // unused out_
         BOOST_ASSERT(out_ ==
             list_.iterator_to(list_.back()));
         if(out_pos_ == 0)
         {
             BOOST_ASSERT(out_ != list_.begin());
             auto& e = *out_;
             list_.erase(out_);
             out_ = list_.end();
             destroy(e);
             out_end_ = 0;
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
         }
     }
 
     auto const replace =
         [&](iter pos, element& e)
         {
             auto it =
                 list_.insert(pos, e);
             auto& e0 = *pos;
             list_.erase(pos);
             destroy(e0);
             return it;
         };
 
     // partial last buffer
     if(out_ != list_.begin() && out_ != list_.end())
     {
         BOOST_ASSERT(out_ ==
             list_.iterator_to(list_.back()));
         BOOST_ASSERT(out_pos_ != 0);
         auto& e = alloc(out_pos_);
         std::memcpy(
             e.data(),
             out_->data(),
             out_pos_);
         replace(out_, e);
         out_ = list_.end();
         out_pos_ = 0;
         out_end_ = 0;
     #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
         debug_check();
     #endif
     }
 
     // partial first buffer
     if(in_pos_ != 0)
     {
         if(out_ != list_.begin())
         {
             auto const n =
                 list_.front().size() - in_pos_;
             auto& e = alloc(n);
             std::memcpy(
                 e.data(),
                 list_.front().data() + in_pos_,
                 n);
             replace(list_.begin(), e);
             in_pos_ = 0;
         }
         else
         {
             BOOST_ASSERT(out_ ==
                 list_.iterator_to(list_.back()));
             BOOST_ASSERT(out_pos_ > in_pos_);
             auto const n = out_pos_ - in_pos_;
             auto& e = alloc(n);
             std::memcpy(
                 e.data(),
                 list_.front().data() + in_pos_,
                 n);
             replace(list_.begin(), e);
             in_pos_ = 0;
             out_ = list_.end();
         }
     #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
         debug_check();
     #endif
     }
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 clear() noexcept
 {
     out_ = list_.begin();
     in_size_ = 0;
     in_pos_ = 0;
     out_pos_ = 0;
     out_end_ = 0;
 }
 
 template<class Allocator>
 auto
 basic_multi_buffer<Allocator>::
 prepare(size_type n) ->
     mutable_buffers_type
 {
     auto const n0 = n;
     if(in_size_ > max_ || n > (max_ - in_size_))
         BOOST_THROW_EXCEPTION(std::length_error{
             "basic_multi_buffer too long"});
     list_type reuse;
     std::size_t total = in_size_;
     // put all empty buffers on reuse list
     if(out_ != list_.end())
     {
         total += out_->size() - out_pos_;
         if(out_ != list_.iterator_to(list_.back()))
         {
             out_end_ = out_->size();
             reuse.splice(reuse.end(), list_,
                 std::next(out_), list_.end());
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
         }
         auto const avail = out_->size() - out_pos_;
         if(n > avail)
         {
             out_end_ = out_->size();
             n -= avail;
         }
         else
         {
             out_end_ = out_pos_ + n;
             n = 0;
         }
     #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
         debug_check();
     #endif
     }
     // get space from reuse buffers
     while(n > 0 && ! reuse.empty())
     {
         auto& e = reuse.front();
         reuse.erase(reuse.iterator_to(e));
         list_.push_back(e);
         total += e.size();
         if(n > e.size())
         {
             out_end_ = e.size();
             n -= e.size();
         }
         else
         {
             out_end_ = n;
             n = 0;
         }
     #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
         debug_check();
     #endif
     }
     BOOST_ASSERT(total <= max_);
     if(! reuse.empty() || n > 0)
     {
         destroy(reuse);
         if(n > 0)
         {
             std::size_t const growth_factor = 2;
             std::size_t altn = in_size_ * growth_factor;
         // Overflow detection:
             if(in_size_ > altn)
                 altn = (std::numeric_limits<std::size_t>::max)();
             else
                 altn = (std::max<std::size_t>)(512, altn);
             auto const size =
                 (std::min<std::size_t>)(
                     max_ - total,
                     (std::max<std::size_t>)(n, altn));
             auto& e = alloc(size);
             list_.push_back(e);
             if(out_ == list_.end())
                 out_ = list_.iterator_to(e);
             out_end_ = n;
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
         }
     }
     auto const result =
         mutable_buffers_type(
             *this, in_size_, n0);
     BOOST_ASSERT(
         net::buffer_size(result) == n0);
     return result;
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 commit(size_type n) noexcept
 {
     if(list_.empty())
         return;
     if(out_ == list_.end())
         return;
     auto const back =
         list_.iterator_to(list_.back());
     while(out_ != back)
     {
         auto const avail =
             out_->size() - out_pos_;
         if(n < avail)
         {
             out_pos_ += n;
             in_size_ += n;
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
             return;
         }
         ++out_;
         n -= avail;
         out_pos_ = 0;
         in_size_ += avail;
     #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
         debug_check();
     #endif
     }
 
     n = (std::min)(n, out_end_ - out_pos_);
     out_pos_ += n;
     in_size_ += n;
     if(out_pos_ == out_->size())
     {
         ++out_;
         out_pos_ = 0;
         out_end_ = 0;
     }
 #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
     debug_check();
 #endif
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 consume(size_type n) noexcept
 {
     if(list_.empty())
         return;
     for(;;)
     {
         if(list_.begin() != out_)
         {
             auto const avail =
                 list_.front().size() - in_pos_;
             if(n < avail)
             {
                 in_size_ -= n;
                 in_pos_ += n;
             #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
                 debug_check();
             #endif
                 break;
             }
             n -= avail;
             in_size_ -= avail;
             in_pos_ = 0;
             auto& e = list_.front();
             list_.erase(list_.iterator_to(e));
             destroy(e);
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
         }
         else
         {
             auto const avail = out_pos_ - in_pos_;
             if(n < avail)
             {
                 in_size_ -= n;
                 in_pos_ += n;
             }
             else
             {
                 in_size_ = 0;
                 if(out_ != list_.iterator_to(list_.back()) ||
                     out_pos_ != out_end_)
                 {
                     in_pos_ = out_pos_;
                 }
                 else
                 {
                     // Input and output sequences are empty, reuse buffer.
                     // Alternatively we could deallocate it.
                     in_pos_ = 0;
                     out_pos_ = 0;
                     out_end_ = 0;
                 }
             }
         #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK
             debug_check();
         #endif
             break;
         }
     }
 }
 
 template<class Allocator>
 template<class OtherAlloc>
 void
 basic_multi_buffer<Allocator>::
 copy_from(basic_multi_buffer<OtherAlloc> const& other)
 {
     clear();
     max_ = other.max_;
     if(other.size() == 0)
         return;
     commit(net::buffer_copy(
         prepare(other.size()), other.data()));
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 move_assign(basic_multi_buffer& other, std::true_type) noexcept
 {
     this->get() = std::move(other.get());
     auto const at_end =
         other.out_ == other.list_.end();
     list_ = std::move(other.list_);
     out_ = at_end ? list_.end() : other.out_;
 
     in_size_ = other.in_size_;
     in_pos_ = other.in_pos_;
     out_pos_ = other.out_pos_;
     out_end_ = other.out_end_;
     max_ = other.max_;
 
     other.in_size_ = 0;
     other.out_ = other.list_.end();
     other.in_pos_ = 0;
     other.out_pos_ = 0;
     other.out_end_ = 0;
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 move_assign(basic_multi_buffer& other, std::false_type)
 {
     if(this->get() != other.get())
     {
         copy_from(other);
     }
     else
     {
         move_assign(other, std::true_type{});
     }
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 copy_assign(
     basic_multi_buffer const& other, std::false_type)
 {
     copy_from(other);
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 copy_assign(
     basic_multi_buffer const& other, std::true_type)
 {
     clear();
     this->get() = other.get();
     copy_from(other);
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 swap(basic_multi_buffer& other) noexcept
 {
     swap(other, typename
         alloc_traits::propagate_on_container_swap{});
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 swap(basic_multi_buffer& other, std::true_type) noexcept
 {
     using std::swap;
     auto const at_end0 =
         out_ == list_.end();
     auto const at_end1 =
         other.out_ == other.list_.end();
     swap(this->get(), other.get());
     swap(list_, other.list_);
     swap(out_, other.out_);
     if(at_end1)
         out_ = list_.end();
     if(at_end0)
         other.out_ = other.list_.end();
     swap(in_size_, other.in_size_);
     swap(in_pos_, other.in_pos_);
     swap(out_pos_, other.out_pos_);
     swap(out_end_, other.out_end_);
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 swap(basic_multi_buffer& other, std::false_type) noexcept
 {
     BOOST_ASSERT(this->get() == other.get());
     using std::swap;
     auto const at_end0 =
         out_ == list_.end();
     auto const at_end1 =
         other.out_ == other.list_.end();
     swap(list_, other.list_);
     swap(out_, other.out_);
     if(at_end1)
         out_ = list_.end();
     if(at_end0)
         other.out_ = other.list_.end();
     swap(in_size_, other.in_size_);
     swap(in_pos_, other.in_pos_);
     swap(out_pos_, other.out_pos_);
     swap(out_end_, other.out_end_);
 }
 
 template<class Allocator>
 void
 swap(
     basic_multi_buffer<Allocator>& lhs,
     basic_multi_buffer<Allocator>& rhs) noexcept
 {
     lhs.swap(rhs);
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 destroy(list_type& list) noexcept
 {
     for(auto it = list.begin();
             it != list.end();)
         destroy(*it++);
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 destroy(element& e)
 {
     auto a = rebind_type{this->get()};
     auto const n =
         (sizeof(element) + e.size() +
             sizeof(align_type) - 1) /
         sizeof(align_type);
     e.~element();
     alloc_traits::deallocate(a,
         reinterpret_cast<align_type*>(&e), n);
 }
 
 template<class Allocator>
 auto
 basic_multi_buffer<Allocator>::
 alloc(std::size_t size) ->
     element&
 {
     if(size > alloc_traits::max_size(this->get()))
         BOOST_THROW_EXCEPTION(std::length_error(
         "A basic_multi_buffer exceeded the allocator's maximum size"));
     auto a = rebind_type{this->get()};
     auto const p = alloc_traits::allocate(a,
         (sizeof(element) + size + sizeof(align_type) - 1) /
             sizeof(align_type));
     return *(::new(p) element(size));
 }
 
 template<class Allocator>
 void
 basic_multi_buffer<Allocator>::
 debug_check() const
 {
 #ifndef NDEBUG
     BOOST_ASSERT(buffer_bytes(data()) == in_size_);
     if(list_.empty())
     {
         BOOST_ASSERT(in_pos_ == 0);
         BOOST_ASSERT(in_size_ == 0);
         BOOST_ASSERT(out_pos_ == 0);
         BOOST_ASSERT(out_end_ == 0);
         BOOST_ASSERT(out_ == list_.end());
         return;
     }
 
     auto const& front = list_.front();
 
     BOOST_ASSERT(in_pos_ < front.size());
 
     if(out_ == list_.end())
     {
         BOOST_ASSERT(out_pos_ == 0);
         BOOST_ASSERT(out_end_ == 0);
     }
     else
     {
         auto const& out = *out_;
         auto const& back = list_.back();
 
         BOOST_ASSERT(out_end_ <= back.size());
         BOOST_ASSERT(out_pos_ <  out.size());
         BOOST_ASSERT(&out != &front || out_pos_ >= in_pos_);
         BOOST_ASSERT(&out != &front || out_pos_ - in_pos_ == in_size_);
         BOOST_ASSERT(&out != &back  || out_pos_ <= out_end_);
     }
 #endif
 }
 
 } // beast
 } // boost
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team