FM / impl

/usr/include/boost/beast/core/impl

Name	Size	Mode	Actions
async_base.hpp	3637	0644	edit dl rm
basic_stream.hpp	26806	0644	edit dl rm
buffered_read_stream.hpp	7196	0644	edit dl rm
buffers_adaptor.hpp	15887	0644	edit dl rm
buffers_cat.hpp	10625	0644	edit dl rm
buffers_prefix.hpp	7471	0644	edit dl rm
buffers_suffix.hpp	4969	0644	edit dl rm
error.hpp	858	0644	edit dl rm
error.ipp	1995	0644	edit dl rm
file_posix.ipp	6897	0644	edit dl rm
file_stdio.ipp	6079	0644	edit dl rm
file_win32.ipp	9972	0644	edit dl rm
flat_buffer.hpp	11900	0644	edit dl rm
flat_static_buffer.hpp	1015	0644	edit dl rm
flat_static_buffer.ipp	1762	0644	edit dl rm
flat_stream.hpp	7792	0644	edit dl rm
multi_buffer.hpp	30613	0644	edit dl rm
read_size.hpp	1989	0644	edit dl rm
saved_handler.hpp	4294	0644	edit dl rm
saved_handler.ipp	1391	0644	edit dl rm
static_buffer.hpp	1039	0644	edit dl rm
static_buffer.ipp	2958	0644	edit dl rm
static_string.hpp	14316	0644	edit dl rm
string.ipp	1444	0644	edit dl rm
string_param.hpp	2150	0644	edit dl rm

Edit: /usr/include/boost/beast/core/impl/read_size.hpp (1989B)

#ifndef BOOST_BEAST_IMPL_READ_SIZE_HPP
#define BOOST_BEAST_IMPL_READ_SIZE_HPP

#include <boost/asio/buffer.hpp>
#include <boost/assert.hpp>
#include <stdexcept>
#include <type_traits>

namespace boost {
namespace beast {

namespace detail {

template<class T, class = void>
struct has_read_size_helper : std::false_type {};

template<class T>
struct has_read_size_helper<T, decltype(
    read_size_helper(std::declval<T&>(), 512),
    (void)0)> : std::true_type
{
};

template<class DynamicBuffer>
std::size_t
read_size(DynamicBuffer& buffer,
    std::size_t max_size, std::true_type)
{
    return read_size_helper(buffer, max_size);
}

template<class DynamicBuffer>
std::size_t
read_size(DynamicBuffer& buffer,
    std::size_t max_size, std::false_type)
{
    static_assert(
        net::is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer type requirements not met");
    auto const size = buffer.size();
    auto const limit = buffer.max_size() - size;
    BOOST_ASSERT(size <= buffer.max_size());
    return std::min<std::size_t>(
        std::max<std::size_t>(512, buffer.capacity() - size),
        std::min<std::size_t>(max_size, limit));
}

} // detail

template<class DynamicBuffer>
std::size_t
read_size(
    DynamicBuffer& buffer, std::size_t max_size)
{
    return detail::read_size(buffer, max_size,
        detail::has_read_size_helper<DynamicBuffer>{});
}

template<class DynamicBuffer>
std::size_t
read_size_or_throw(
    DynamicBuffer& buffer, std::size_t max_size)
{
    auto const n = read_size(buffer, max_size);
    if(n == 0)
        BOOST_THROW_EXCEPTION(std::length_error{
            "buffer overflow"});
    return n;
}

} // beast
} // boost

#endif

// // 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_READ_SIZE_HPP #define BOOST_BEAST_IMPL_READ_SIZE_HPP #include #include #include #include namespace boost { namespace beast { namespace detail { template struct has_read_size_helper : std::false_type {}; template struct has_read_size_helper(), 512), (void)0)> : std::true_type { }; template std::size_t read_size(DynamicBuffer& buffer, std::size_t max_size, std::true_type) { return read_size_helper(buffer, max_size); } template std::size_t read_size(DynamicBuffer& buffer, std::size_t max_size, std::false_type) { static_assert( net::is_dynamic_buffer::value, "DynamicBuffer type requirements not met"); auto const size = buffer.size(); auto const limit = buffer.max_size() - size; BOOST_ASSERT(size <= buffer.max_size()); return std::min( std::max(512, buffer.capacity() - size), std::min(max_size, limit)); } } // detail template std::size_t read_size( DynamicBuffer& buffer, std::size_t max_size) { return detail::read_size(buffer, max_size, detail::has_read_size_helper{}); } template std::size_t read_size_or_throw( DynamicBuffer& buffer, std::size_t max_size) { auto const n = read_size(buffer, max_size); if(n == 0) BOOST_THROW_EXCEPTION(std::length_error{ "buffer overflow"}); return n; } } // beast } // boost #endif