mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-20 11:05:54 +00:00
836 lines
20 KiB
C++
836 lines
20 KiB
C++
//
|
|
// Copyright (c) 2013-2016 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_IMPL_BASIC_STREAMBUF_IPP
|
|
#define BEAST_IMPL_BASIC_STREAMBUF_IPP
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <exception>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
namespace beast {
|
|
|
|
/* These diagrams illustrate the layout and state variables.
|
|
|
|
Input and output contained entirely in one element:
|
|
|
|
0 out_
|
|
|<-------------+------------------------------------------->|
|
|
in_pos_ out_pos_ out_end_
|
|
|
|
|
|
Output contained in first and second elements:
|
|
|
|
out_
|
|
|<------+----------+------->| |<----------+-------------->|
|
|
in_pos_ out_pos_ out_end_
|
|
|
|
|
|
Output contained in the second element:
|
|
|
|
out_
|
|
|<------------+------------>| |<----+-------------------->|
|
|
in_pos_ out_pos_ out_end_
|
|
|
|
|
|
Output contained in second and third elements:
|
|
|
|
out_
|
|
|<-----+-------->| |<-------+------>| |<--------------->|
|
|
in_pos_ out_pos_ out_end_
|
|
|
|
|
|
Input sequence is empty:
|
|
|
|
out_
|
|
|<------+------------------>| |<-----------+------------->|
|
|
out_pos_ out_end_
|
|
in_pos_
|
|
|
|
|
|
Output sequence is empty:
|
|
|
|
out_
|
|
|<------+------------------>| |<------+------------------>|
|
|
in_pos_ out_pos_
|
|
out_end_
|
|
|
|
|
|
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_
|
|
|
|
|
|
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
|
|
*/
|
|
|
|
template<class Allocator>
|
|
class basic_streambuf<Allocator>::element
|
|
: public boost::intrusive::list_base_hook<
|
|
boost::intrusive::link_mode<
|
|
boost::intrusive::normal_link>>
|
|
{
|
|
using size_type = typename std::allocator_traits<Allocator>::size_type;
|
|
|
|
size_type const size_;
|
|
|
|
public:
|
|
element(element const&) = delete;
|
|
element& operator=(element const&) = delete;
|
|
|
|
explicit
|
|
element(size_type n)
|
|
: size_(n)
|
|
{
|
|
}
|
|
|
|
size_type
|
|
size() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
char*
|
|
data() const
|
|
{
|
|
return const_cast<char*>(
|
|
reinterpret_cast<char const*>(this+1));
|
|
}
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class Allocator>
|
|
class basic_streambuf<Allocator>::const_buffers_type::const_iterator
|
|
{
|
|
basic_streambuf const* sb_ = nullptr;
|
|
typename list_type::const_iterator it_;
|
|
|
|
public:
|
|
using value_type =
|
|
typename const_buffers_type::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&& other) = default;
|
|
const_iterator(const_iterator const& other) = default;
|
|
const_iterator& operator=(const_iterator&& other) = default;
|
|
const_iterator& operator=(const_iterator const& other) = default;
|
|
|
|
const_iterator(basic_streambuf const& sb,
|
|
typename list_type::const_iterator const& it)
|
|
: sb_(&sb)
|
|
, it_(it)
|
|
{
|
|
}
|
|
|
|
bool
|
|
operator==(const_iterator const& other) const
|
|
{
|
|
return sb_ == other.sb_ && it_ == other.it_;
|
|
}
|
|
|
|
bool
|
|
operator!=(const_iterator const& other) const
|
|
{
|
|
return !(*this == other);
|
|
}
|
|
|
|
reference
|
|
operator*() const
|
|
{
|
|
auto const& e = *it_;
|
|
return value_type{e.data(),
|
|
(sb_->out_ == sb_->list_.end() ||
|
|
&e != &*sb_->out_) ? e.size() : sb_->out_pos_} +
|
|
(&e == &*sb_->list_.begin() ? sb_->in_pos_ : 0);
|
|
}
|
|
|
|
pointer
|
|
operator->() const = delete;
|
|
|
|
const_iterator&
|
|
operator++()
|
|
{
|
|
++it_;
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator++(int)
|
|
{
|
|
auto temp = *this;
|
|
++(*this);
|
|
return temp;
|
|
}
|
|
|
|
const_iterator&
|
|
operator--()
|
|
{
|
|
--it_;
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator--(int)
|
|
{
|
|
auto temp = *this;
|
|
--(*this);
|
|
return temp;
|
|
}
|
|
};
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::const_buffers_type::const_buffers_type(
|
|
basic_streambuf const& sb)
|
|
: sb_(&sb)
|
|
{
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::const_buffers_type::begin() const ->
|
|
const_iterator
|
|
{
|
|
return const_iterator{*sb_, sb_->list_.begin()};
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::const_buffers_type::end() const ->
|
|
const_iterator
|
|
{
|
|
return const_iterator{*sb_, sb_->out_ ==
|
|
sb_->list_.end() ? sb_->list_.end() :
|
|
std::next(sb_->out_)};
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class Allocator>
|
|
class basic_streambuf<Allocator>::mutable_buffers_type::const_iterator
|
|
{
|
|
basic_streambuf const* sb_ = nullptr;
|
|
typename list_type::const_iterator it_;
|
|
|
|
public:
|
|
using value_type =
|
|
typename mutable_buffers_type::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&& other) = default;
|
|
const_iterator(const_iterator const& other) = default;
|
|
const_iterator& operator=(const_iterator&& other) = default;
|
|
const_iterator& operator=(const_iterator const& other) = default;
|
|
|
|
const_iterator(basic_streambuf const& sb,
|
|
typename list_type::const_iterator const& it)
|
|
: sb_(&sb)
|
|
, it_(it)
|
|
{
|
|
}
|
|
|
|
bool
|
|
operator==(const_iterator const& other) const
|
|
{
|
|
return sb_ == other.sb_ && it_ == other.it_;
|
|
}
|
|
|
|
bool
|
|
operator!=(const_iterator const& other) const
|
|
{
|
|
return !(*this == other);
|
|
}
|
|
|
|
reference
|
|
operator*() const
|
|
{
|
|
auto const& e = *it_;
|
|
return value_type{e.data(),
|
|
&e == &*std::prev(sb_->list_.end()) ?
|
|
sb_->out_end_ : e.size()} +
|
|
(&e == &*sb_->out_ ? sb_->out_pos_ : 0);
|
|
}
|
|
|
|
pointer
|
|
operator->() const = delete;
|
|
|
|
const_iterator&
|
|
operator++()
|
|
{
|
|
++it_;
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator++(int)
|
|
{
|
|
auto temp = *this;
|
|
++(*this);
|
|
return temp;
|
|
}
|
|
|
|
const_iterator&
|
|
operator--()
|
|
{
|
|
--it_;
|
|
return *this;
|
|
}
|
|
|
|
const_iterator
|
|
operator--(int)
|
|
{
|
|
auto temp = *this;
|
|
--(*this);
|
|
return temp;
|
|
}
|
|
};
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::mutable_buffers_type::mutable_buffers_type(
|
|
basic_streambuf const& sb)
|
|
: sb_(&sb)
|
|
{
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::mutable_buffers_type::begin() const ->
|
|
const_iterator
|
|
{
|
|
return const_iterator{*sb_, sb_->out_};
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::mutable_buffers_type::end() const ->
|
|
const_iterator
|
|
{
|
|
return const_iterator{*sb_, sb_->list_.end()};
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::~basic_streambuf()
|
|
{
|
|
delete_list();
|
|
}
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::
|
|
basic_streambuf(basic_streambuf&& other)
|
|
: detail::empty_base_optimization<allocator_type>(
|
|
std::move(other.member()))
|
|
, alloc_size_(other.alloc_size_)
|
|
, in_size_(other.in_size_)
|
|
, in_pos_(other.in_pos_)
|
|
, out_pos_(other.out_pos_)
|
|
, out_end_(other.out_end_)
|
|
{
|
|
auto const at_end =
|
|
other.out_ == other.list_.end();
|
|
list_ = std::move(other.list_);
|
|
out_ = at_end ? list_.end() : other.out_;
|
|
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_streambuf<Allocator>::
|
|
basic_streambuf(basic_streambuf&& other,
|
|
allocator_type const& alloc)
|
|
: basic_streambuf(other.alloc_size_, alloc)
|
|
{
|
|
using boost::asio::buffer_copy;
|
|
if(this->member() != other.member())
|
|
commit(buffer_copy(prepare(other.size()), other.data()));
|
|
else
|
|
move_assign(other, std::true_type{});
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::operator=(
|
|
basic_streambuf&& other) -> basic_streambuf&
|
|
{
|
|
if(this == &other)
|
|
return *this;
|
|
// VFALCO If any memory allocated we could use it first?
|
|
clear();
|
|
alloc_size_ = other.alloc_size_;
|
|
move_assign(other, std::integral_constant<bool,
|
|
alloc_traits::propagate_on_container_move_assignment::value>{});
|
|
return *this;
|
|
}
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::
|
|
basic_streambuf(basic_streambuf const& other)
|
|
: basic_streambuf(other.alloc_size_,
|
|
alloc_traits::select_on_container_copy_construction(other.member()))
|
|
{
|
|
commit(boost::asio::buffer_copy(prepare(other.size()), other.data()));
|
|
}
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::
|
|
basic_streambuf(basic_streambuf const& other,
|
|
allocator_type const& alloc)
|
|
: basic_streambuf(other.alloc_size_, alloc)
|
|
{
|
|
commit(boost::asio::buffer_copy(prepare(other.size()), other.data()));
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::operator=(
|
|
basic_streambuf const& other) ->
|
|
basic_streambuf&
|
|
{
|
|
if(this == &other)
|
|
return *this;
|
|
using boost::asio::buffer_copy;
|
|
clear();
|
|
copy_assign(other, std::integral_constant<bool,
|
|
alloc_traits::propagate_on_container_copy_assignment::value>{});
|
|
commit(buffer_copy(prepare(other.size()), other.data()));
|
|
return *this;
|
|
}
|
|
|
|
template<class Allocator>
|
|
template<class OtherAlloc>
|
|
basic_streambuf<Allocator>::basic_streambuf(
|
|
basic_streambuf<OtherAlloc> const& other)
|
|
: basic_streambuf(other.alloc_size_)
|
|
{
|
|
using boost::asio::buffer_copy;
|
|
commit(buffer_copy(prepare(other.size()), other.data()));
|
|
}
|
|
|
|
template<class Allocator>
|
|
template<class OtherAlloc>
|
|
basic_streambuf<Allocator>::basic_streambuf(
|
|
basic_streambuf<OtherAlloc> const& other,
|
|
allocator_type const& alloc)
|
|
: basic_streambuf(other.alloc_size_, alloc)
|
|
{
|
|
using boost::asio::buffer_copy;
|
|
commit(buffer_copy(prepare(other.size()), other.data()));
|
|
}
|
|
|
|
template<class Allocator>
|
|
template<class OtherAlloc>
|
|
auto
|
|
basic_streambuf<Allocator>::operator=(
|
|
basic_streambuf<OtherAlloc> const& other) ->
|
|
basic_streambuf&
|
|
{
|
|
using boost::asio::buffer_copy;
|
|
clear();
|
|
commit(buffer_copy(prepare(other.size()), other.data()));
|
|
return *this;
|
|
}
|
|
|
|
template<class Allocator>
|
|
basic_streambuf<Allocator>::basic_streambuf(
|
|
std::size_t alloc_size, Allocator const& alloc)
|
|
: detail::empty_base_optimization<allocator_type>(alloc)
|
|
, out_(list_.end())
|
|
, alloc_size_(alloc_size)
|
|
{
|
|
if(alloc_size <= 0)
|
|
throw std::invalid_argument(
|
|
"basic_streambuf: invalid alloc_size");
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::prepare(size_type n) ->
|
|
mutable_buffers_type
|
|
{
|
|
iterator pos = out_;
|
|
if(pos != list_.end())
|
|
{
|
|
auto const avail = pos->size() - out_pos_;
|
|
if(n > avail)
|
|
{
|
|
n -= avail;
|
|
out_end_ = pos->size();
|
|
while(++pos != list_.end())
|
|
{
|
|
if(n < pos->size())
|
|
{
|
|
out_end_ = n;
|
|
n = 0;
|
|
++pos;
|
|
break;
|
|
}
|
|
n -= pos->size();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
++pos;
|
|
out_end_ = out_pos_ + n;
|
|
n = 0;
|
|
}
|
|
}
|
|
|
|
if(n > 0)
|
|
{
|
|
assert(pos == list_.end());
|
|
for(;;)
|
|
{
|
|
auto const size = std::max(alloc_size_, n);
|
|
auto& e = *reinterpret_cast<element*>(
|
|
alloc_traits::allocate(this->member(),
|
|
size + sizeof(element)));
|
|
alloc_traits::construct(this->member(), &e, size);
|
|
list_.push_back(e);
|
|
if(out_ == list_.end())
|
|
{
|
|
out_ = list_.iterator_to(e);
|
|
debug_check();
|
|
}
|
|
if(n <= size)
|
|
{
|
|
out_end_ = n;
|
|
debug_check();
|
|
break;
|
|
}
|
|
n -= size;
|
|
debug_check();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while(pos != list_.end())
|
|
{
|
|
auto& e = *pos++;
|
|
list_.erase(list_.iterator_to(e));
|
|
auto const len = e.size() + sizeof(e);
|
|
alloc_traits::destroy(this->member(), &e);
|
|
alloc_traits::deallocate(this->member(),
|
|
reinterpret_cast<std::uint8_t*>(&e), len);
|
|
}
|
|
debug_check();
|
|
}
|
|
|
|
return mutable_buffers_type(*this);
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::commit(size_type n)
|
|
{
|
|
if(list_.empty())
|
|
return;
|
|
if(out_ == list_.end())
|
|
return;
|
|
auto const last = std::prev(list_.end());
|
|
while(out_ != last)
|
|
{
|
|
auto const avail =
|
|
out_->size() - out_pos_;
|
|
if(n < avail)
|
|
{
|
|
out_pos_ += n;
|
|
in_size_ += n;
|
|
debug_check();
|
|
return;
|
|
}
|
|
++out_;
|
|
n -= avail;
|
|
out_pos_ = 0;
|
|
in_size_ += avail;
|
|
debug_check();
|
|
}
|
|
|
|
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;
|
|
}
|
|
debug_check();
|
|
}
|
|
|
|
template<class Allocator>
|
|
auto
|
|
basic_streambuf<Allocator>::data() const ->
|
|
const_buffers_type
|
|
{
|
|
return const_buffers_type(*this);
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::consume(size_type n)
|
|
{
|
|
if(list_.empty())
|
|
return;
|
|
|
|
auto pos = list_.begin();
|
|
for(;;)
|
|
{
|
|
if(pos != out_)
|
|
{
|
|
auto const avail = pos->size() - in_pos_;
|
|
if(n < avail)
|
|
{
|
|
in_size_ -= n;
|
|
in_pos_ += n;
|
|
debug_check();
|
|
break;
|
|
}
|
|
n -= avail;
|
|
in_size_ -= avail;
|
|
in_pos_ = 0;
|
|
debug_check();
|
|
|
|
element& e = *pos++;
|
|
list_.erase(list_.iterator_to(e));
|
|
auto const len = e.size() + sizeof(e);
|
|
alloc_traits::destroy(this->member(), &e);
|
|
alloc_traits::deallocate(this->member(),
|
|
reinterpret_cast<std::uint8_t*>(&e), len);
|
|
}
|
|
else
|
|
{
|
|
auto const avail = out_pos_ - in_pos_;
|
|
if(n < avail)
|
|
{
|
|
in_size_ -= n;
|
|
in_pos_ += n;
|
|
}
|
|
else
|
|
{
|
|
in_size_ -= avail;
|
|
if(out_pos_ != out_end_||
|
|
out_ != list_.iterator_to(list_.back()))
|
|
{
|
|
in_pos_ = out_pos_;
|
|
}
|
|
else
|
|
{
|
|
// Use the whole buffer now.
|
|
// Alternatively we could deallocate it.
|
|
in_pos_ = 0;
|
|
out_pos_ = 0;
|
|
out_end_ = 0;
|
|
}
|
|
}
|
|
debug_check();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::clear()
|
|
{
|
|
delete_list();
|
|
list_.clear();
|
|
out_ = list_.begin();
|
|
in_size_ = 0;
|
|
in_pos_ = 0;
|
|
out_pos_ = 0;
|
|
out_end_ = 0;
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::
|
|
move_assign(basic_streambuf& other, std::false_type)
|
|
{
|
|
using boost::asio::buffer_copy;
|
|
if(this->member() != other.member())
|
|
{
|
|
commit(buffer_copy(prepare(other.size()), other.data()));
|
|
other.clear();
|
|
}
|
|
else
|
|
move_assign(other, std::true_type{});
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::
|
|
move_assign(basic_streambuf& other, std::true_type)
|
|
{
|
|
this->member() = std::move(other.member());
|
|
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>
|
|
void
|
|
basic_streambuf<Allocator>::
|
|
copy_assign(basic_streambuf const& other, std::false_type)
|
|
{
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::
|
|
copy_assign(basic_streambuf const& other, std::true_type)
|
|
{
|
|
this->member() = other.member();
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::delete_list()
|
|
{
|
|
for(auto iter = list_.begin(); iter != list_.end();)
|
|
{
|
|
auto& e = *iter++;
|
|
auto const n = e.size() + sizeof(e);
|
|
alloc_traits::destroy(this->member(), &e);
|
|
alloc_traits::deallocate(this->member(),
|
|
reinterpret_cast<std::uint8_t*>(&e), n);
|
|
}
|
|
}
|
|
|
|
// Returns the number of bytes which can be
|
|
// prepared without causing a memory allocation.
|
|
template<class Allocator>
|
|
std::size_t
|
|
basic_streambuf<Allocator>::prepare_size() const
|
|
{
|
|
auto pos = out_;
|
|
if(pos == list_.end())
|
|
return 0;
|
|
auto n = pos->size() - out_pos_;
|
|
while(++pos != list_.end())
|
|
n += pos->size();
|
|
return n;
|
|
}
|
|
|
|
template<class Allocator>
|
|
void
|
|
basic_streambuf<Allocator>::debug_check() const
|
|
{
|
|
#ifndef NDEBUG
|
|
if(list_.empty())
|
|
{
|
|
assert(in_pos_ == 0);
|
|
assert(in_size_ == 0);
|
|
assert(out_pos_ == 0);
|
|
assert(out_end_ == 0);
|
|
assert(out_ == list_.end());
|
|
return;
|
|
}
|
|
|
|
auto const& front = list_.front();
|
|
|
|
assert(in_pos_ < front.size());
|
|
|
|
if(out_ == list_.end())
|
|
{
|
|
assert(out_pos_ == 0);
|
|
assert(out_end_ == 0);
|
|
}
|
|
else
|
|
{
|
|
auto const& out = *out_;
|
|
auto const& back = list_.back();
|
|
|
|
assert(out_end_ <= back.size());
|
|
assert(out_pos_ < out.size());
|
|
assert(&out != &front || out_pos_ >= in_pos_);
|
|
assert(&out != &front || out_pos_ - in_pos_ == in_size_);
|
|
assert(&out != &back || out_pos_ <= out_end_);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
template<class Alloc, class T>
|
|
basic_streambuf<Alloc>&
|
|
operator<<(basic_streambuf<Alloc>& buf, T const& t)
|
|
{
|
|
using boost::asio::buffer;
|
|
using boost::asio::buffer_copy;
|
|
std::stringstream ss;
|
|
ss << t;
|
|
auto const& s = ss.str();
|
|
buf.commit(buffer_copy(buf.prepare(s.size()),
|
|
boost::asio::buffer(s)));
|
|
return buf;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class Allocator>
|
|
std::size_t
|
|
read_size_helper(basic_streambuf<
|
|
Allocator> const& streambuf, std::size_t max_size)
|
|
{
|
|
return std::min<std::size_t>(max_size,
|
|
std::max<std::size_t>(512, streambuf.prepare_size()));
|
|
}
|
|
|
|
template<class Allocator>
|
|
std::string
|
|
to_string(basic_streambuf<Allocator> const& streambuf)
|
|
{
|
|
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;
|
|
}
|
|
|
|
} // beast
|
|
|
|
#endif
|