FM / core

/usr/include/boost/beast/core

Name	Size	Mode	Actions
detail/	-	0755	rm
impl/	-	0755	rm
async_base.hpp	26461	0644	edit dl rm
basic_stream.hpp	55342	0644	edit dl rm
bind_handler.hpp	4172	0644	edit dl rm
buffered_read_stream.hpp	11877	0644	edit dl rm
buffers_adaptor.hpp	6783	0644	edit dl rm
buffers_cat.hpp	3383	0644	edit dl rm
buffers_prefix.hpp	6152	0644	edit dl rm
buffers_range.hpp	4211	0644	edit dl rm
buffers_suffix.hpp	3971	0644	edit dl rm
buffers_to_string.hpp	1770	0644	edit dl rm
buffer_traits.hpp	5757	0644	edit dl rm
detect_ssl.hpp	22345	0644	edit dl rm
error.hpp	2257	0644	edit dl rm
file.hpp	1028	0644	edit dl rm
file_base.hpp	5015	0644	edit dl rm
file_posix.hpp	4222	0644	edit dl rm
file_stdio.hpp	3849	0644	edit dl rm
file_win32.hpp	4248	0644	edit dl rm
flat_buffer.hpp	15427	0644	edit dl rm
flat_static_buffer.hpp	8706	0644	edit dl rm
flat_stream.hpp	12603	0644	edit dl rm
make_printable.hpp	2803	0644	edit dl rm
multi_buffer.hpp	18153	0644	edit dl rm
ostream.hpp	2690	0644	edit dl rm
rate_policy.hpp	4592	0644	edit dl rm
read_size.hpp	1844	0644	edit dl rm
role.hpp	1322	0644	edit dl rm
saved_handler.hpp	3788	0644	edit dl rm
span.hpp	4787	0644	edit dl rm
static_buffer.hpp	8515	0644	edit dl rm
static_string.hpp	25720	0644	edit dl rm
stream_traits.hpp	16399	0644	edit dl rm
string.hpp	1941	0644	edit dl rm
string_param.hpp	3459	0644	edit dl rm
string_type.hpp	1092	0644	edit dl rm
tcp_stream.hpp	853	0644	edit dl rm

Edit: /usr/include/boost/beast/core/flat_static_buffer.hpp (8706B)

//
// 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_FLAT_STATIC_BUFFER_HPP
#define BOOST_BEAST_FLAT_STATIC_BUFFER_HPP

#include <boost/beast/core/detail/config.hpp>
#include <boost/asio/buffer.hpp>
#include <algorithm>
#include <cstddef>
#include <cstring>

namespace boost {
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.
    */
    BOOST_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.
    */
    BOOST_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.
    */
    BOOST_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.
    */
    BOOST_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
} // boost

#include <boost/beast/core/impl/flat_static_buffer.hpp>
#ifdef BOOST_BEAST_HEADER_ONLY
#include <boost/beast/core/impl/flat_static_buffer.ipp>
#endif

#endif

cmd: