//

// 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 BEAST_MULTI_BUFFER_HPP

#define BEAST_MULTI_BUFFER_HPP

#include <beast/core/detail/config.hpp>

#include <beast/core/detail/allocator.hpp>

#include <asio/buffer.hpp>

#include <beast/core/empty_value.hpp>

#include <beast/core/type_with_alignment.hpp>

#include <iterator>

#include <limits>

#include <memory>

#include <type_traits>

#include <list>

namespace beast {

/** A dynamic buffer providing sequences of variable length.

A dynamic buffer encapsulates memory storage that may be

automatically resized as required, where the memory is

divided into two regions: readable bytes followed by

writable bytes. These memory regions are internal to

the dynamic buffer, but direct access to the elements

is provided to permit them to be efficiently used with

I/O operations.

The implementation uses a sequence of one or more byte

arrays of varying sizes to represent the readable and

writable bytes. Additional byte array objects are

appended to the sequence to accommodate changes in the

desired size. The behavior and implementation of this

container is most similar to `std::deque`.

Objects of this type meet the requirements of <em>DynamicBuffer</em>

and have the following additional properties:

@li A mutable buffer sequence representing the readable

bytes is returned by @ref data when `this` is non-const.

@li Buffer sequences representing the readable and writable

bytes, returned by @ref data and @ref prepare, may have

length greater than one.

@li A configurable maximum size may be set upon construction

and adjusted afterwards. Calls to @ref prepare that would

exceed this size will throw `std::length_error`.

@li Sequences previously obtained using @ref data remain

valid after calls to @ref prepare or @ref commit.

@tparam Allocator The allocator to use for managing memory.

*/

template<class Allocator>

class basic_multi_buffer

#if ! BEAST_DOXYGEN

: private beast::empty_value<Allocator>

#endif

{

// Fancy pointers are not supported

static_assert(std::is_pointer<typename

std::allocator_traits<Allocator>::pointer>::value,

"Allocator must use regular pointers");

static bool constexpr default_nothrow =

std::is_nothrow_default_constructible<Allocator>::value;

// Storage for the list of buffers representing the input

// and output sequences. The allocation for each element

// contains `element` followed by raw storage bytes.

class element

{

using size_type = typename

detail::allocator_traits<Allocator>::size_type;

size_type const size_;

public:

element(element const&) = delete;

explicit

element(size_type n) noexcept

: size_(n)

{

}

size_type

size() const noexcept

{

return size_;

}

char*

data() const noexcept

{

return const_cast<char*>(

reinterpret_cast<char const*>(this + 1));

}

};

template<bool>

class subrange;

using size_type = typename

detail::allocator_traits<Allocator>::size_type;

using align_type = typename

beast::type_with_alignment<alignof(element)>::type;

using rebind_type = typename

beast::detail::allocator_traits<Allocator>::

template rebind_alloc<align_type>;

using alloc_traits =

beast::detail::allocator_traits<rebind_type>;

using list_type = typename std::list<element*>;

using iter = typename list_type::iterator;

using const_iter = typename list_type::const_iterator;

using pocma = typename

alloc_traits::propagate_on_container_move_assignment;

using pocca = typename

alloc_traits::propagate_on_container_copy_assignment;

static_assert(std::is_base_of<std::bidirectional_iterator_tag,

typename std::iterator_traits<iter>::iterator_category>::value,

"BidirectionalIterator type requirements not met");

static_assert(std::is_base_of<std::bidirectional_iterator_tag,

typename std::iterator_traits<const_iter>::iterator_category>::value,

"BidirectionalIterator type requirements not met");

std::size_t max_;

list_type list_; // list of allocated buffers

iter out_; // element that contains out_pos_

size_type in_size_ = 0; // size of the input sequence

size_type in_pos_ = 0; // input offset in list_.front()

size_type out_pos_ = 0; // output offset in *out_

size_type out_end_ = 0; // output end offset in list_.back()

public:

#if BEAST_DOXYGEN

/// The ConstBufferSequence used to represent the readable bytes.

using const_buffers_type = __implementation_defined__;

/// The MutableBufferSequence used to represent the writable bytes.

using mutable_buffers_type = __implementation_defined__;

#else

using const_buffers_type = subrange<false>;

using mutable_buffers_type = subrange<true>;

#endif

/// The type of allocator used.

using allocator_type = Allocator;

/// Destructor

~basic_multi_buffer();

/** Constructor

After construction, @ref capacity will return zero, and

@ref max_size will return the largest value which may

be passed to the allocator's `allocate` function.

*/

basic_multi_buffer() noexcept(default_nothrow);

/** Constructor

After construction, @ref capacity will return zero, and

@ref max_size will return the specified value of `limit`.

@param limit The desired maximum size.

*/

explicit

basic_multi_buffer(

std::size_t limit) noexcept(default_nothrow);

/** Constructor

After construction, @ref capacity will return zero, and

@ref max_size will return the largest value which may

be passed to the allocator's `allocate` function.

@param alloc The allocator to use for the object.

@esafe

No-throw guarantee.

*/

explicit

basic_multi_buffer(Allocator const& alloc) noexcept;

/** Constructor

After construction, @ref capacity will return zero, and

@ref max_size will return the specified value of `limit`.

@param limit The desired maximum size.

@param alloc The allocator to use for the object.

@esafe

No-throw guarantee.

*/

basic_multi_buffer(

std::size_t limit, Allocator const& alloc) noexcept;

/** Move Constructor

The container is constructed with the contents of `other`

using move semantics. The maximum size will be the same

as the moved-from object.

Buffer sequences previously obtained from `other` using

@ref data or @ref prepare remain valid after the move.

@param other The object to move from. After the move, the

moved-from object will have zero capacity, zero readable

bytes, and zero writable bytes.

@esafe

No-throw guarantee.

*/

basic_multi_buffer(basic_multi_buffer&& other) noexcept;

/** Move Constructor

Using `alloc` as the allocator for the new container, the

contents of `other` are moved. If `alloc != other.get_allocator()`,

this results in a copy. The maximum size will be the same

as the moved-from object.

Buffer sequences previously obtained from `other` using

@ref data or @ref prepare become invalid after the move.

@param other The object to move from. After the move,

the moved-from object will have zero capacity, zero readable

bytes, and zero writable bytes.

@param alloc The allocator to use for the object.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of `alloc`.

*/

basic_multi_buffer(

basic_multi_buffer&& other,

Allocator const& alloc);

/** Copy Constructor

This container is constructed with the contents of `other`

using copy semantics. The maximum size will be the same

as the copied object.

@param other The object to copy from.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of the allocator.

*/

basic_multi_buffer(basic_multi_buffer const& other);

/** Copy Constructor

This container is constructed with the contents of `other`

using copy semantics and the specified allocator. The maximum

size will be the same as the copied object.

@param other The object to copy from.

@param alloc The allocator to use for the object.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of `alloc`.

*/

basic_multi_buffer(basic_multi_buffer const& other,

Allocator const& alloc);

/** Copy Constructor

This container is constructed with the contents of `other`

using copy semantics. The maximum size will be the same

as the copied object.

@param other The object to copy from.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of the allocator.

*/

template<class OtherAlloc>

basic_multi_buffer(basic_multi_buffer<

OtherAlloc> const& other);

/** Copy Constructor

This container is constructed with the contents of `other`

using copy semantics. The maximum size will be the same

as the copied object.

@param other The object to copy from.

@param alloc The allocator to use for the object.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of `alloc`.

*/

template<class OtherAlloc>

basic_multi_buffer(

basic_multi_buffer<OtherAlloc> const& other,

allocator_type const& alloc);

/** Move Assignment

The container is assigned with the contents of `other`

using move semantics. The maximum size will be the same

as the moved-from object.

Buffer sequences previously obtained from `other` using

@ref data or @ref prepare remain valid after the move.

@param other The object to move from. After the move,

the moved-from object will have zero capacity, zero readable

bytes, and zero writable bytes.

*/

basic_multi_buffer&

operator=(basic_multi_buffer&& other);

/** Copy Assignment

The container is assigned with the contents of `other`

using copy semantics. The maximum size will be the same

as the copied object.

After the copy, `this` will have zero writable bytes.

@param other The object to copy from.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of the allocator.

*/

basic_multi_buffer& operator=(

basic_multi_buffer const& other);

/** Copy Assignment

The container is assigned with the contents of `other`

using copy semantics. The maximum size will be the same

as the copied object.

After the copy, `this` will have zero writable bytes.

@param other The object to copy from.

@throws std::length_error if `other.size()` exceeds the

maximum allocation size of the allocator.

*/

template<class OtherAlloc>

basic_multi_buffer& operator=(

basic_multi_buffer<OtherAlloc> const& other);

/// Returns a copy of the allocator used.

allocator_type

get_allocator() const

{

return this->get();

}

/** Set the maximum allowed capacity

This function changes the currently configured upper limit

on capacity to the specified value.

@param n The maximum number of bytes ever allowed for capacity.

@esafe

No-throw guarantee.

*/

void

max_size(std::size_t n) noexcept

{

max_ = n;

}

/** Guarantee a minimum capacity

This function adjusts the internal storage (if necessary)

to guarantee space for at least `n` bytes.

Buffer sequences previously obtained using @ref data remain

valid, while buffer sequences previously obtained using

@ref prepare become invalid.

@param n The minimum number of byte for the new capacity.

If this value is greater than the maximum size, then the

maximum size will be adjusted upwards to this value.

@throws std::length_error if n is larger than the maximum

allocation size of the allocator.

@esafe

Strong guarantee.

*/

void

reserve(std::size_t n);

/** Reallocate the buffer to fit the readable bytes exactly.

Buffer sequences previously obtained using @ref data or

@ref prepare become invalid.

@esafe

Strong guarantee.

*/

void

shrink_to_fit();

/** Set the size of the readable and writable bytes to zero.

This clears the buffer without changing capacity.

Buffer sequences previously obtained using @ref data or

@ref prepare become invalid.

@esafe

No-throw guarantee.

*/

void

clear() noexcept;

/// Exchange two dynamic buffers

template<class Alloc>

friend

void

swap(

basic_multi_buffer<Alloc>& lhs,

basic_multi_buffer<Alloc>& rhs) noexcept;

//--------------------------------------------------------------------------

/// Returns the number of readable bytes.

size_type

size() const noexcept

{

return in_size_;

}

/// Return the maximum number of bytes, both readable and writable, that can ever be held.

size_type

max_size() const noexcept

{

return max_;

}

/// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation.

std::size_t

capacity() const noexcept;

/** Returns a constant buffer sequence representing the readable bytes

@note The sequence may contain multiple contiguous memory regions.

*/

const_buffers_type

data() const noexcept;

/** Returns a constant buffer sequence representing the readable bytes

@note The sequence may contain multiple contiguous memory regions.

*/

const_buffers_type

cdata() const noexcept

{

return data();

}

/** Returns a mutable buffer sequence representing the readable bytes.

@note The sequence may contain multiple contiguous memory regions.

*/

mutable_buffers_type

data() noexcept;

/** Returns a mutable buffer sequence representing writable bytes.

Returns a mutable buffer sequence representing the writable

bytes containing exactly `n` bytes of storage. Memory may be

reallocated as needed.

All buffer sequences previously obtained using @ref prepare are

invalidated. Buffer sequences previously obtained using @ref data

remain valid.

@param n The desired number of bytes in the returned buffer

sequence.

@throws std::length_error if `size() + n` exceeds `max_size()`.

@esafe

Strong guarantee.

*/

mutable_buffers_type

prepare(size_type n);

/** Append writable bytes to the readable bytes.

Appends n bytes from the start of the writable bytes to the

end of the readable bytes. The remainder of the writable bytes

are discarded. If n is greater than the number of writable

bytes, all writable bytes are appended to the readable bytes.

All buffer sequences previously obtained using @ref prepare are

invalidated. Buffer sequences previously obtained using @ref data

remain valid.

@param n The number of bytes to append. If this number

is greater than the number of writable bytes, all

writable bytes are appended.

@esafe

No-throw guarantee.

*/

void

commit(size_type n) noexcept;

/** Remove bytes from beginning of the readable bytes.

Removes n bytes from the beginning of the readable bytes.

All buffers sequences previously obtained using

@ref data or @ref prepare are invalidated.

@param n The number of bytes to remove. If this number

is greater than the number of readable bytes, all

readable bytes are removed.

@esafe

No-throw guarantee.

*/

void

consume(size_type n) noexcept;

private:

template<class OtherAlloc>

friend class basic_multi_buffer;

template<class OtherAlloc>

void copy_from(basic_multi_buffer<OtherAlloc> const&);

void move_assign(basic_multi_buffer& other, std::false_type);

void move_assign(basic_multi_buffer& other, std::true_type) noexcept;

void copy_assign(basic_multi_buffer const& other, std::false_type);

void copy_assign(basic_multi_buffer const& other, std::true_type);

void swap(basic_multi_buffer&) noexcept;

void swap(basic_multi_buffer&, std::true_type) noexcept;

void swap(basic_multi_buffer&, std::false_type) noexcept;

void destroy(list_type& list) noexcept;

void destroy(const_iter it);

void destroy(element& e);

element& alloc(std::size_t size);

void debug_check() const;

};

/// A typical multi buffer

using multi_buffer = basic_multi_buffer<std::allocator<char>>;

} // beast

#include <beast/core/impl/multi_buffer.hpp>

#endif