//

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

#define BEAST_FLAT_STATIC_BUFFER_HPP

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

#include <asio/buffer.hpp>

#include <algorithm>

#include <cstddef>

#include <cstring>

namespace beast {

/** A dynamic buffer using a fixed size internal buffer.

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.

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, will have

length one.

@li Ownership of the underlying storage belongs to the

derived class.

@note Variables are usually declared using the template class

@ref flat_static_buffer; however, to reduce the number of template

instantiations, objects should be passed `flat_static_buffer_base&`.

@see flat_static_buffer

*/

class flat_static_buffer_base

{

char* begin_;

char* in_;

char* out_;

char* last_;

char* end_;

flat_static_buffer_base(

flat_static_buffer_base const& other) = delete;

flat_static_buffer_base& operator=(

flat_static_buffer_base const&) = delete;

public:

/** Constructor

This creates a dynamic buffer using the provided storage area.

@param p A pointer to valid storage of at least `n` bytes.

@param n The number of valid bytes pointed to by `p`.

*/

flat_static_buffer_base(

void* p, std::size_t n) noexcept

{

reset(p, n);

}

/** Clear the readable and writable bytes to zero.

This function causes the readable and writable bytes

to become empty. The capacity is not changed.

Buffer sequences previously obtained using @ref data or

@ref prepare become invalid.

@esafe

No-throw guarantee.

*/

BEAST_DECL

void

clear() noexcept;

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

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

using const_buffers_type = net::const_buffer;

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

using mutable_buffers_type = net::mutable_buffer;

/// Returns the number of readable bytes.

std::size_t

size() const noexcept

{

return out_ - in_;

}

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

std::size_t

max_size() const noexcept

{

return dist(begin_, end_);

}

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

std::size_t

capacity() const noexcept

{

return max_size();

}

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

const_buffers_type

data() const noexcept

{

return {in_, dist(in_, out_)};

}

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

const_buffers_type

cdata() const noexcept

{

return data();

}

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

mutable_buffers_type

data() noexcept

{

return {in_, dist(in_, out_)};

}

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

Returns a mutable buffer sequence representing the writable

bytes containing exactly `n` bytes of storage.

All buffers sequences previously obtained using

@ref data or @ref prepare are invalidated.

@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.

*/

BEAST_DECL

mutable_buffers_type

prepare(std::size_t 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 buffers sequences previously obtained using

@ref data or @ref prepare are invalidated.

@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(std::size_t n) noexcept

{

out_ += (std::min<std::size_t>)(n, last_ - out_);

}

/** 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.

*/

BEAST_DECL

void

consume(std::size_t n) noexcept;

protected:

/** Constructor

The buffer will be in an undefined state. It is necessary

for the derived class to call @ref reset with a pointer

and size in order to initialize the object.

*/

flat_static_buffer_base() = default;

/** Reset the pointed-to buffer.

This function resets the internal state to the buffer provided.

All input and output sequences are invalidated. This function

allows the derived class to construct its members before

initializing the static buffer.

@param p A pointer to valid storage of at least `n` bytes.

@param n The number of valid bytes pointed to by `p`.

@esafe

No-throw guarantee.

*/

BEAST_DECL

void

reset(void* p, std::size_t n) noexcept;

private:

static

std::size_t

dist(char const* first, char const* last) noexcept

{

return static_cast<std::size_t>(last - first);

}

};

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

/** A <em>DynamicBuffer</em> with a fixed size internal buffer.

Buffer sequences returned by @ref data and @ref prepare

will always be of length one.

This implements a dynamic buffer using no memory allocations.

@tparam N The number of bytes in the internal buffer.

@note To reduce the number of template instantiations when passing

objects of this type in a deduced context, the signature of the

receiving function should use @ref flat_static_buffer_base instead.

@see flat_static_buffer_base

*/

template<std::size_t N>

class flat_static_buffer : public flat_static_buffer_base

{

char buf_[N];

public:

/// Constructor

flat_static_buffer(flat_static_buffer const&);

/// Constructor

flat_static_buffer()

: flat_static_buffer_base(buf_, N)

{

}

/// Assignment

flat_static_buffer& operator=(flat_static_buffer const&);

/// Returns the @ref flat_static_buffer_base portion of this object

flat_static_buffer_base&

base()

{

return *this;

}

/// Returns the @ref flat_static_buffer_base portion of this object

flat_static_buffer_base const&

base() const

{

return *this;

}

/// Return the maximum sum of the input and output sequence sizes.

std::size_t constexpr

max_size() const

{

return N;

}

/// Return the maximum sum of input and output sizes that can be held without an allocation.

std::size_t constexpr

capacity() const

{

return N;

}

};

} // beast

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

#ifdef BEAST_HEADER_ONLY

#include <beast/core/impl/flat_static_buffer.ipp>

#endif

#endif