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/string_param.hpp (3459B)

#ifndef BOOST_BEAST_STRING_PARAM_HPP
#define BOOST_BEAST_STRING_PARAM_HPP

#if defined(BOOST_BEAST_ALLOW_DEPRECATED) && !defined(BOOST_BEAST_DOXYGEN)

#include <boost/beast/core/detail/config.hpp>
#include <boost/beast/core/string.hpp>
#include <boost/beast/core/static_string.hpp>
#include <boost/beast/core/detail/static_ostream.hpp>
#include <boost/optional.hpp>

namespace boost {
namespace beast {

/** A function parameter which efficiently converts to string.

This is used as a function parameter type to allow callers
    notational convenience: objects other than strings may be
    passed in contexts where a string is expected. The conversion
    to string is made using `operator<<` to a non-dynamically
    allocated static buffer if possible, else to a `std::string`
    on overflow.

To use it, modify your function signature to accept
    `string_param` and then extract the string inside the
    function:
    @code
    void print(string_param s)
    {
        std::cout << s.str();
    }
    @endcode
*/
class string_param
{
    string_view sv_;
    char buf_[128];
    boost::optional<detail::static_ostream> os_;

template<class T>
    typename std::enable_if<
        std::is_integral<T>::value>::type
    print(T const&);

template<class T>
    typename std::enable_if<
        ! std::is_integral<T>::value &&
        ! std::is_convertible<T, string_view>::value
    >::type
    print(T const&);

void
    print(string_view);

template<class T>
    typename std::enable_if<
        std::is_integral<T>::value>::type
    print_1(T const&);

template<class T>
    typename std::enable_if<
        ! std::is_integral<T>::value>::type
    print_1(T const&);

void
    print_n()
    {
    }

template<class T0, class... TN>
    void
    print_n(T0 const&, TN const&...);

template<class T0, class T1, class... TN>
    void
    print(T0 const&, T1 const&, TN const&...);

public:
    /// Copy constructor (disallowed)
    string_param(string_param const&) = delete;

/// Copy assignment (disallowed)
    string_param& operator=(string_param const&) = delete;

/** Constructor

This function constructs a string as if by concatenating
        the result of streaming each argument in order into an
        output stream. It is used as a notational convenience
        at call sites which expect a parameter with the semantics
        of a @ref string_view.

The implementation uses a small, internal static buffer
        to avoid memory allocations especially for the case where
        the list of arguments to be converted consists of a single
        integral type.

@param args One or more arguments to convert
    */
    template<class... Args>
    string_param(Args const&... args);

/// Returns the contained string
    string_view
    str() const
    {
        return sv_;
    }

/// Implicit conversion to @ref string_view
    operator string_view const() const
    {
        return sv_;
    }
};

} // beast
} // boost

#include <boost/beast/core/impl/string_param.hpp>

#endif // defined(BOOST_BEAST_ALLOW_DEPRECATED) && !BOOST_BEAST_DOXYGEN

#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_STRING_PARAM_HPP #define BOOST_BEAST_STRING_PARAM_HPP #if defined(BOOST_BEAST_ALLOW_DEPRECATED) && !defined(BOOST_BEAST_DOXYGEN) #include #include #include #include #include namespace boost { namespace beast { /** A function parameter which efficiently converts to string. This is used as a function parameter type to allow callers notational convenience: objects other than strings may be passed in contexts where a string is expected. The conversion to string is made using `operator<<` to a non-dynamically allocated static buffer if possible, else to a `std::string` on overflow. To use it, modify your function signature to accept `string_param` and then extract the string inside the function: @code void print(string_param s) { std::cout << s.str(); } @endcode */ class string_param { string_view sv_; char buf_[128]; boost::optional os_; template typename std::enable_if< std::is_integral::value>::type print(T const&); template typename std::enable_if< ! std::is_integral::value && ! std::is_convertible::value >::type print(T const&); void print(string_view); template typename std::enable_if< std::is_integral::value>::type print_1(T const&); template typename std::enable_if< ! std::is_integral::value>::type print_1(T const&); void print_n() { } template void print_n(T0 const&, TN const&...); template void print(T0 const&, T1 const&, TN const&...); public: /// Copy constructor (disallowed) string_param(string_param const&) = delete; /// Copy assignment (disallowed) string_param& operator=(string_param const&) = delete; /** Constructor This function constructs a string as if by concatenating the result of streaming each argument in order into an output stream. It is used as a notational convenience at call sites which expect a parameter with the semantics of a @ref string_view. The implementation uses a small, internal static buffer to avoid memory allocations especially for the case where the list of arguments to be converted consists of a single integral type. @param args One or more arguments to convert */ template string_param(Args const&... args); /// Returns the contained string string_view str() const { return sv_; } /// Implicit conversion to @ref string_view operator string_view const() const { return sv_; } }; } // beast } // boost #include #endif // defined(BOOST_BEAST_ALLOW_DEPRECATED) && !BOOST_BEAST_DOXYGEN #endif